Build a Metabolic Pathway Model Sandbox with OpenCode

New to OpenCode? Start with OpenCode setup, model providers and course budget, then return here for your chosen app.

Know what your pathway model predicts before you trust a plot

A pathway model is a list of reactions with rate equations. A simulator turns it into curves, and curves always look convincing, even when a typo in the model file has created matter from nothing. Pathway Model Sandbox draws a small reaction network, simulates it for the sulfate supply you choose, and checks that no sulfur is created or lost before it lets you compare two runs.

You will build it with OpenCode, one request at a time, and check each number with pencil and calculator. The app runs locally in your browser: one file, no installation, no upload. The model is a deliberately simplified teaching model of how a plant leaf turns sulfate into cysteine. Its parameter values are illustrative, not measured, and it is not a validated physiological model. Your own permitted parameters come in at Step 16.

The real result: a simulator you own, understand and can extend. You will practise the whole cycle, including three real corrections the recorded build needed.

(opens in a new tab)

You will finish with: a local simulator whose steady states you can derive by hand (sulfate 200, sulfite 2.50, sulfide 2.00, cysteine 40.00 nmol/g FW), that flags a model which creates sulfur and refuses to compare it.

First watch the 2:01 result tour. It shows where you are going. The numbered steps below are the lesson: what to click in OpenCode, what to paste, and what must appear before you continue.

Silent, with on-screen explanations. OpenCode scenes are captures from the recorded build; app scenes operate the actual OpenCode-generated app. Captions and highlights were added afterwards. Read the transcript (opens in a new tab) · Download the movie (opens in a new tab).

Use: keep this manual beside OpenCode and your browser. Complete each Success check before continuing. Click any screenshot to enlarge it.

Files: reference kit: working app, four checkpoints, four model files and the exact requests (opens in a new tab). Extract the ZIP first: Windows right-click → Extract All; Mac double-click. Keep it beside your project.

Your personal coach: Step 4 turns your OpenCode session into a one-step-at-a-time guide. For help later, paste the complete coach brief (opens in a new tab) into your project session and tell it your step number.

The biology in five sentences. Plants take up sulfate (SO₄²⁻) from the soil and reduce it, mostly in chloroplasts, to sulfide. The model lumps the first enzymes (ATP sulfurylase and APS reductase, which turn sulfate into sulfite) into one reaction, R1. Sulfite reductase (R2) turns sulfite into sulfide; sulfite is toxic, so a real cell keeps it low. OAS-TL (R3) joins sulfide to a carbon backbone and makes cysteine, the first amino acid carrying sulfur. Cysteine is then used for proteins, glutathione and more (R4), which here simply means it leaves the model.

Four words you will meet. A pool is the amount of one substance, here in nmol/g FW (nanomoles per gram of fresh leaf). A rate law says how fast a reaction runs: mass-action means rate = k × amount (twice the substrate, twice the rate); Michaelis–Menten means the enzyme saturates: rate = Vmax × amount / (Km + amount), never above Vmax. Steady state means every pool stays constant because what flows in equals what flows out. Sulfur balance: sulfur atoms cannot appear or vanish, so sulfur in the pools plus sulfur used must equal sulfur at the start plus sulfur supplied.

Files for this journey

Download everything at once as the reference kit (ZIP) (opens in a new tab), or single files as you reach the step that needs them. Save each file into your project folder under exactly this name. If a file opens in the browser instead of downloading, press Ctrl+S (Mac: Command+S) to save it.

The kit also contains the finished app, the recorded checkpoints (checkpoints/…) and the exact prompts.

1. Get OpenCode readyLink to step

Do

1. Open an ordinary website. Complete your university Wi-Fi sign-in if prompted.
2. Install OpenCode Desktop: follow Step 1 of Set up OpenCode in the L1 book Start With OpenCode.
3. Open OpenCode. For English labels, use Settings → Preferences → Language → English. In German: Einstellungen → Präferenzen → Sprache → English.

Success: OpenCode opens. Continue to the project; choose the model in Step 3.

If different: installation or Wi-Fi failure → use the seminar recovery card.

2. Open your projectLink to step

Do

1. In Finder or File Explorer, create a folder named pathway-model in Documents.
2. Copy the data folder from the extracted reference kit into pathway-model. It holds four small model files in JSON (a plain-text format for structured data): model.json (opens in a new tab), broken-model.json (opens in a new tab), negative-rate-model.json (opens in a new tab) and no-sulfur-model.json (opens in a new tab).
3. In OpenCode, click Home → Add project.
4. Select your pathway-model folder. Click Select folder.
5. Click New session.

(opens in a new tab)

Success: the new-session screen shows pathway-model below the message box.

If different: another folder name → return Home and add the correct folder.

3. Select a working modelLink to step

Do: click the model name below the message box. Select the model assigned for the seminar. Wait until its name appears below the box.

(opens in a new tab)

Success: a model name is displayed. The next step checks that it answers.

If different: no working model or access → ask the instructor to confirm the seminar connection. This recording used Space Bunny Free; on the recording day the menu showed another default first, so we selected it by hand. Free availability is not guaranteed. A model you do not see can be switched on under Manage models.

Agent control: if Plan is visible, select Build before requesting edits. In the recorded interface the agent selector is hidden and Build is the default.

4. Start your OpenCode coachLink to step

Do: copy this block, paste it into OpenCode's message box and click the upward Send arrow.

Be my patient app-building coach. I am a beginner.
We will build Pathway Model Sandbox in this folder, one step at a time.
Use one index.html with inline HTML, CSS and JavaScript,
no packages, server or network calls.
The data folder holds a synthetic teaching model: model.json and broken-model.json.
Explain in at most four short lines: Do, See, Success, If different.
Wait for my result before continuing.
Never claim to see my browser unless you actually inspected it.
Do not create files yet. Reply:
"Ready. Your project is pathway-model. Next: draw the network."

Wait: while OpenCode works, Send turns into Stop. Continue only when Stop has disappeared.

(opens in a new tab)

Success: OpenCode replies Ready. Your project is pathway-model. No file is created yet.

If different: an access or quota error → return to Step 3. Do not reinstall OpenCode to fix a model quota.

5. Draw the network: your first screenLink to step

Open data/model.json in a text editor and look before you ask for anything. It lists four species (each with sulfur, the sulfur atoms per molecule, and an initial amount), four reactions with their rate laws, a supply of 20 nmol/g FW per hour into sulfate, and the simulation settings (120 h in steps of 0.01 h). The app will read exactly this file.

Do: paste this into the same session and click Send. Wait for Stop to disappear (about three minutes in the recording).

Create only index.html in this project. Build the first Pathway Model Sandbox
screen with inline HTML, CSS and JavaScript: no packages, server or network.
Clean light design, dark teal heading, system fonts, labelled controls.
Add a "Load example" button and a file input labelled "Model file (JSON)".
Read data/model.json now and embed it exactly as the example,
because a double-clicked page cannot read files by itself.
Show the model name and its status sentence.
Draw the network as inline SVG: one box per species (name and id), left to right;
one arrow per reaction labelled with its id; an incoming arrow labelled with
supply.name into supply.to; a reaction with an empty "to" leaves the model.
Then a species table: id, name, sulfur atoms, initial amount, unit.
And a reactions table: id, name, from → to, rate law with its parameters:
mass-action v = k·[substrate]; michaelis-menten v = Vmax·[S]/(Km + [S]).
Rate unit is units.amount per units.time, e.g. nmol/g FW/h.
Show "4 species · 4 reactions · supply 20 nmol/g FW/h".
Initially show "No model yet. Click Load example."
Invalid JSON or an unknown species id: a visible error naming it, and no diagram.
No simulation yet. Save index.html, tell me how to open it, then wait.

(opens in a new tab)

Success: OpenCode says index.html was saved and tells you to open it.

If different: code appears only in the chat → send "Save that code as index.html in this project. Tell me the saved path." If a permission request appears, allow the file edit only when it names your project.

6. Open the app, check the network, keep a copyLink to step

Do

1. In Finder or File Explorer, open pathway-model and double-click index.html. If a text editor opens instead, right-click → Open With → your browser.
2. Click Load example.

(opens in a new tab)

Success: the summary reads 4 species · 4 reactions · supply 20 nmol/g FW/h. The network runs Sulfate → R1 → Sulfite → R2 → Sulfide → R3 → Cysteine → R4 → leaves model, with the uptake arrow into Sulfate. The reactions table shows R2 as v = 60·[SO3]/(5 + [SO3]).

If different: a reaction points the wrong way → send "R1 goes from SO4 to SO3. The diagram shows [what you see]. Draw every arrow from its "from" species to its "to" species. Fix only that."

Keep: copy the whole pathway-model folder beside the original and name the copy pathway-model-01-working. Continue in the original. Recorded recovery file: checkpoints/05-first-screen/index.html in the kit; copy it into a new folder, never over your own work.

7. Simulate with RK4Link to step

A computer cannot follow a curve continuously; it takes many small time steps. The simplest method takes the current rates and steps forward along them (Euler's method); errors pile up. The classical Runge–Kutta method (RK4) looks at the rates four times inside each step (start, twice in the middle, end) and averages them with weights 1-2-2-1. With steps of 0.01 h it is accurate to far more digits than we display.

Do: send:

The network shows SO4 → SO3 → H2S → Cys, the uptake arrow and R4 leaving.
Now simulate. Integrate from 0 to simulation.end h with a fixed step of
simulation.step h using the classical Runge–Kutta method (RK4).
Rates come from the reactions table; the supply adds supply.rate per hour to supply.to.
Compute time as i × step; never add steps up. Do not clamp or invent values.
Add a "Run simulation" button; also run automatically after a model loads.
Draw one small line chart per species (inline SVG), each with its own y-axis
starting at 0, time in h on the x-axis and the amount unit on the y-axis.
Add a "Times (h)" input, default "0, 6, 12, 24, 48, 120", and a table of
every species' amount at those times, two decimals.
Add a short box "How the simulation works" in plain words: RK4 moves in small
time steps; in each step it samples the rates four times and averages them
with weights 1-2-2-1, which is far more accurate than one sample per step.
Expect at 120 h: SO4 200.00, SO3 2.50, H2S 2.00, Cys 40.00; at 6 h Cys 18.83.
Keep the network and tables. Save index.html; tell me what to check, then wait.

Wait for Stop to disappear. Refresh the browser (Ctrl+R, Mac Command+R) and click Load example.

The numbers were right first time, but the recorded table was hard to read: the headers sat squeezed on the left, the values far off on the right.

(opens in a new tab)

Success: four small charts (one per species) and an Amounts at selected times table appear. The 120 h row reads 200.00 · 2.50 · 2.00 · 40.00.

If different: one chart holds all four species → sulfite and sulfide (about 2) would be flat lines under sulfate (200). Send "Draw one chart per species, each with its own y-axis, so small pools stay visible."

8. Correct the table layoutLink to step

Do: describe what you see, not "it looks wrong". Send:

At 120 h I see SO4 200.00, SO3 2.50, H2S 2.00 and Cys 40.00. The numbers are right.
But the "Amounts at selected times" table is misaligned: the headers sit
squeezed at the left, while the time column is wide and the four value
columns are pushed to the far right, far from their headers.
Put every value directly under its own header, numbers right-aligned,
and let the table use the page width evenly.
Also move the Network section back to just below the model name,
so the page reads: model → network → simulation → charts → table.
Add x-axis ticks at 0, 24, 48, 72, 96 and 120 h to every chart.
Change only the layout. Save index.html; tell me what to check, then wait.

Refresh and click Load example.

(opens in a new tab)

Success: the network is back at the top; each chart has ticks at 0, 24 … 120 h; every value sits under its header.

If different: your table was already aligned → send only the last two layout sentences, or skip.

9. Check the steady state by handLink to step

At steady state every pool is constant, so for each pool in = out. The only way in is the supply, 20 nmol/g FW per hour, so every reaction must carry 20 per hour:

Do: compare with the table in the app:

(opens in a new tab)

Success: the 120 h row equals the hand-derived steady state. At 6 h, cysteine reads 18.83. These in-between values were confirmed with two separate solvers outside the app (a fine-step RK4 and an adaptive solver, agreeing to 0.00000001).

If different: sulfite does not settle at 2.50 while the other three match → check the R2 row of the reactions table, then send "R2 must be v = Vmax·[SO3]/(Km + [SO3]) with Vmax 60 and Km 5. Sulfite must settle at 2.50. Fix only that."

Keep: copy your project as pathway-model-02-working. Recorded recovery file: checkpoints/07-table-fix/index.html.

10. Add controls, steady-state rule and response timeLink to step

Do: send:

The table is aligned and the network is back at the top.
Add two sliders, each with a number box: "Sulfate supply (nmol/g FW/h)"
0–80, step 1, default supply.rate; and "Sulfite reductase Vmax (nmol/g FW/h)"
10–120, step 1, default the Vmax of the michaelis-menten reaction (R2).
Rerun on every change. They change only this run, never the loaded model;
add a "Reset to model" button.
Add a "Steady state" table, one row per species: value at the end,
rate of change at the end (three decimals, per h), and "Time to 95% of end
value" (one decimal, h: the first time the amount reaches 95% of its end value).
Steady state is reached only if every pool changes by less than
0.01 nmol/g FW per h at the end. Otherwise show "No steady state by 120 h:
[names] still changing" and "—" for every 95% time.
Expect defaults: Cys 29.6 h, SO4 27.1 h.
Supply 40: SO4 400.00, SO3 10.00, H2S 4.00, Cys 80.00.
Supply 70 with Vmax 60: no steady state, Sulfite still changing.
Keep everything else. Save index.html; tell me what to check, then wait.

Wait, refresh, click Load example. Scroll to Steady state.

Success: Steady state reached by 120 h. Time to 95%: sulfate 27.1 h, cysteine 29.6 h.

Check sulfate by hand: with no reaction feeding back, sulfate follows SO4(t) = 200 − 150·e^(−0.1·t) (it starts at 50 and approaches 200). It reaches 95% of 200 = 190 when e^(−0.1·t) = 1/15, so t = 10 × ln 15 = 27.08 h, shown as 27.1. Cysteine's 29.6 h cannot be done on paper; an adaptive solver outside the app gave 29.59 h.

If different: a 95% time differs by more than 0.1 h → quote the app's numbers and the definition from the request, and ask OpenCode to show you the lines that compute it before it changes anything.

11. Double the supply, then overload the enzymeLink to step

Do

1. Type 40 in the supply number box and press Enter.

(opens in a new tab)

Success: sulfate, sulfide and cysteine double (400.00, 4.00, 80.00) but sulfite rises four-fold, from 2.50 to 10.00: 5 × 40 / (60 − 40) = 10. Sulfite reductase now runs at 40 of its maximum 60, close to saturation, so sulfite must build up much more to push the same flux through. A linear (mass-action) step would only have doubled.

2. Set supply back to 20 and Vmax to 30. Sulfite again reads 10.00 (5 × 20 / (30 − 20)); the other pools stay at 200, 2 and 40.
3. Set Vmax back to 60 and supply to 70.

(opens in a new tab)

Success: No steady state by 120 h: Sulfite still changing, every 95% time shows —, and sulfite climbs by about 10.28 per hour (70 in, a little under 60 out) to 1060.67. Cysteine levels off near 120 = 60 / 0.5, because sulfite reductase can deliver at most 60 per hour. In a real leaf such a sulfite build-up would be toxic; real plants also oxidise excess sulfite back to sulfate, which this model leaves out.

Click Reset to model before you continue.

Keep: recorded recovery file checkpoints/08-controls/index.html.

12. Add the sulfur balance, then load a broken modelLink to step

A model file can be wrong in ways no plot reveals. The sulfur balance is a bookkeeping check: sulfur in the pools + sulfur used − sulfur supplied − sulfur at the start must stay 0.

Do: send:

Supply 40 doubles SO4, H2S and Cys, but Sulfite goes from 2.50 to 10.00.
Now add a sulfur balance check. Sulfur atoms per molecule come from "sulfur".
Integrate two extra RK4 variables with the same steps: sulfur supplied
(supply rate × sulfur atoms of supply.to) and sulfur used (flux of each
reaction with an empty "to" × sulfur atoms of its substrates).
Residual = sulfur in pools + used − supplied − sulfur in pools at time 0.
Show a "Sulfur balance" panel for the end time: in pools, used, supplied,
initial, residual (three decimals, nmol S/g FW), and "Balanced" if
|residual| ≤ 0.001 at every step, otherwise "Unbalanced".
Also check each reaction before simulating: sulfur atoms in "from" must
equal those in "to" unless "to" is empty. Name every failing reaction,
e.g. "R2 Sulfite reductase (SiR): 1 S in, 2 S out".
An unbalanced model is still drawn and simulated, but a red banner says
"Sulfur balance fails: comparisons disabled".
Expect model.json: residual 0.000, used 2205.501; broken-model.json: R2
named, residual about 2247.501.
Keep everything else. Save index.html; tell me what to check, then wait.

Refresh and click Load example. Scroll to Sulfur balance.

Success (correct model): Balanced. In pools 244.499 + used 2205.501 − supplied 2400.000 (20 × 120 h) − initial 50.000 = residual 0.000.

Do: now click Model file (JSON) and choose data/broken-model.json. Open it in a text editor too: one number differs. R2 turns 1 sulfite into 2 sulfide.

(opens in a new tab)

Success: the red banner names R2 Sulfite reductase (SiR): 1 S in, 2 S out; the balance says Unbalanced with residual 2247.501. Note that the curves still look smooth and plausible: cysteine simply settles at 80 instead of 40. Only the bookkeeping shows the model is impossible.

If different: the balance says Balanced for the broken file → send "broken-model.json makes 2 sulfide from 1 sulfite. The balance must be Unbalanced and name R2. Check the residual at every step."

13. Compare two runsLink to step

Do: send:

model.json is Balanced, residual 0.000. broken-model.json names R2 and shows the red banner.
Now add comparison. A "Keep as baseline" button stores the current run
with its supply and Vmax. When the current run differs, draw the baseline
as a dashed grey line in every species chart, with a legend
"baseline (supply 20, Vmax 60)" and "current (supply 40, Vmax 60)".
Add a comparison table: species, baseline end value, current end value,
ratio current / baseline (two decimals).
"Keep as baseline" and the comparison are disabled while the sulfur balance
fails, with the reason next to the button. Loading a model clears the baseline.
Expect baseline defaults, current supply 40: ratio SO4 2.00, SO3 4.00,
H2S 2.00, Cys 2.00.
Keep everything else. Save index.html; tell me what to check, then wait.

Refresh, click Load example, click Keep as baseline, then type 40 as supply and press Enter.

(opens in a new tab)

Success: ratios 2.00 · 4.00 · 2.00 · 2.00, and every chart shows a dashed grey baseline under the solid current curve (the picture at the top of this manual). Now choose data/broken-model.json: Keep as baseline is greyed out with the reason beside it, and the comparison disappears.

If different: the broken model can still be kept as baseline → send "With broken-model.json loaded, Keep as baseline must be disabled and the comparison hidden."

Keep: copy the project as pathway-model-03-working. Recorded recovery file: checkpoints/10-compare/index.html.

14. Make it yoursLink to step

Do: send:

Supply 40 gives ratios 2.00, 4.00, 2.00, 2.00, and the broken model disables comparison.
Change only the visible heading to "My Pathway Sandbox".
Keep the browser title consistent.
Do not change the model, checks, simulation, charts or comparison.
Save index.html and tell me which lines changed.

Refresh and click Load example.

Success: the heading reads My Pathway Sandbox; OpenCode names two changed lines (browser title and heading). Cysteine still settles at 40.00.

If different: anything else changed → ask OpenCode to undo that part, or restore index.html from your latest checkpoint.

15. Leave a README and continue in a fresh sessionLink to step

Do: send:

Read index.html, then create README.md with exact instructions for
opening and using this app: the model.json fields (species with sulfur atoms
and initial amounts, reactions with mass-action or michaelis-menten rates,
supply, units, simulation end and step), where data is processed, the method
(fixed-step RK4, 0.01 h), the sulfur balance rule and tolerance, the steady-state
rule, and the stated limits: a teaching model with illustrative parameters,
not a validated physiological model; no regulation, compartments or fitting.
Known checks: steady state SO4 200, SO3 2.50, H2S 2, Cys 40 (supply 20,
Vmax 60); supply 40 gives SO3 10; broken-model.json flags R2.
Record this next task: import a small SBML file. Do not implement it.
Do not change index.html. Tell me which file you created, then wait.

Then click New session (the + beside the session tab). Confirm pathway-model is still the project. If the button says New project, click it, select your original pathway-model folder and click Select folder. Send:

Read README.md and index.html without editing.
Tell me the app's purpose, how to open it and the recorded next task.
Keep the answer to three bullets.

(opens in a new tab)

Success: the new session names the purpose, double-clicking index.html, and the SBML next task, all from your files.

If different: empty project → check the folder. Wrong facts → correct README.md first; it is your memory between sessions.

16. Test edited models, then your own permitted parametersLink to step

Before you type your own values, test what a typing mistake does. negative-rate-model.json has k = −0.1 in R1; no-sulfur-model.json lacks the sulfur count of sulfite.

Do: load both files in the app. The recorded build accepted them: with k = −0.1, sulfite ended at −40,689,545.56 (a negative amount), yet the balance said Balanced, because sulfur was still conserved. With the missing count it showed NaN ("not a number"). A balance check proves bookkeeping, not biology. Continue in your fresh session and send:

Before I use my own parameters, I tested edited copies of model.json.
data/negative-rate-model.json has k = -0.1 in R1: Sulfite ends at
-40689545.56, yet the sulfur balance says "Balanced".
data/no-sulfur-model.json has no "sulfur" for Sulfite: the balance shows NaN.
Check every model before drawing or simulating: each species needs a whole
number "sulfur" ≥ 0 and a number "initial" ≥ 0; every k, Vmax and Km must be
a number > 0; supply.rate a number ≥ 0. Name the item and the problem, e.g.
"R1: k must be a number greater than 0 (found -0.1)."
While such an error is shown: no diagram, charts or results, and no
"Model loaded." message. Loading model.json again brings everything back.
Also: with supply 0 every "Time to 95%" shows 0.0. Show "—" for a pool
whose end value is not above its initial amount.
Change only this. Save index.html; tell me what to check, then wait.

OpenCode reported that every 95% time would now show "—" at supply 0. We checked: sulfite, sulfide and cysteine still showed 0.0 h (they start at 0 and end a hair above 0). Never mark a step done because the AI says so. We sent:

The negative k and the missing sulfur are now named errors. Two details remain.
For a missing value the message says "(found undefined)": write "(missing)".
With supply 0 every pool drains, yet Sulfite, Sulfide and Cysteine still show
"Time to 95% of end value" 0.0 h, because they start at 0 and end near 0.
Show a 95% time only for a pool that rises by at least 0.01 nmol/g FW from
its initial amount to its end value; otherwise show "—".
Defaults must still give Cys 29.6 h and SO4 27.1 h.
Change only this. Save index.html; tell me what to check, then wait.

Refresh, then load negative-rate-model.json again.

(opens in a new tab)

Success: the error names R1 and −0.1; nothing else is shown. no-sulfur-model.json names SO3 and its missing sulfur. At supply 0 every 95% time shows —. model.json brings back 200 / 2.50 / 2 / 40.

Now your own parameters

1. Use only values you are allowed to use: published values you may cite, or your own measurements with permission. Never paste unpublished or personal data into a model without permission. The app sends nothing; OpenCode can read every file inside the project folder, so save a copy with unpublished values outside it.
2. Copy model.json, rename it (for example my-model.json) and change one value in a text editor, e.g. R4's k. Keep the units consistent (nmol/g FW and h), or change units too.
3. Load it through Model file (JSON). Predict one steady state by hand first: with only R4 changed, cysteine = supply / k.

Success: your hand prediction matches the app, and the balance says Balanced.

If different: your pathway has a reaction with two substrates or a feedback → this app cannot express it. Tell OpenCode the rate law you need, using made-up numbers, and ask for that one addition.

17. Let a colleague use itLink to step

Do: give a colleague index.html, README.md and the data folder. Ask them to follow README.md, load broken-model.json and tell you which reaction is wrong and why comparison is disabled. Let them click without your help.

Success: they name R2 (1 S in, 2 S out) and can explain in one sentence why a smooth curve is not proof that a model is right.

If they stop: add the missing instruction to README.md. Repeat from that instruction.

18. Make your next improvementLink to step

Do: save a working checkpoint. The recorded next task is importing a small SBML file (SBML is the standard exchange format for such models, read by tools like COPASI). A smaller first step could be an export of the selected-times table with the parameters in every row. Write your request with this pattern:

Add [one behaviour] so [my user] can [purpose].
Keep [working features].
I will know it works when [visible result].
Tell me which part will change, implement only this improvement,
then wait for me to try it.

Success: the new behaviour works and the example still gives 200.00 / 2.50 / 2.00 / 40.00, residual 0.000, and R2 flagged in the broken model. Record the next task in README.md.

If stuck: paste this into your coach chat:

I am on step [number].
I did: [exact action].
I expected: [result from the manual].
I see: [actual text/result, or describe a screenshot].
Give me one next action. Wait for my result.

What this app does not do: it is a teaching model with illustrative parameter values, not a validated physiological model. It has no regulation (in real plants APS reductase is strongly controlled by sulfur status, and OAS, the carbon backbone for cysteine, is assumed to be always available), no compartments (chloroplast versus cytosol), no sulfite detoxification, no parameter fitting, no uncertainty and no stochastic effects. It reads only its own JSON format, not SBML or COPASI files, and supports single-substrate mass-action and Michaelis–Menten rates only.

The method behind these steps

Structure it: one model file listing species, sulfur atoms, reactions and units, and a balance rule that must hold. Understand it: derive the steady states and the 27.1 h response by hand before trusting any curve. Choose tools: one offline HTML file, RK4 with a fixed small step, OpenCode as the builder, pencil and calculator as the judge. Build it: one request, one check, one checkpoint at a time, with corrections phrased as observations. Read T01-L01 · From Idea to Working Result: The Four-Quadrant Method.