Building Your Own Workflow

You now know more about how this works than almost everyone using it daily. That knowledge is worth nothing on its own. What decides whether AI is a genuine multiplier for you or a way to produce median text slightly faster is a handful of habits — and habits are built deliberately, not absorbed.

So: the assembly.

The core, one more time

Everything compresses into three questions, asked before you hand anything over:

1. Is the material on the desk, or does this need knowledge from outside? On the desk → transformation, its strongest mode. From memory, about something recent or specific → the weakest.
2. Can the result be checked by something outside the model? Runnable code, a document to quote, a number to recompute → delegate freely. Nothing to check against → your judgement is the only check, so you'd better have it.
3. What does an error cost? Cheap → don't verify, iterate. Expensive → verify every atom, every time.

Underneath all three sits the rule that has come back in every stage: don't delegate what you couldn't evaluate.

Audit your week

Systems get built from your actual work, not from someone's list of use cases. One pass, half an hour:

Write down where your week goes. Real tasks, honestly, including the ones you resent.

Split them into goal skills and overhead. Which of these am I trying to get better at, and which do I want to be done with? That line is yours, and nobody else can draw it for you.

Mark what repeats. Weekly, daily, several times a day.

Mark what has a checkable outcome. Runs or doesn't, matches the source or doesn't, meets an explicit criterion or doesn't.

Repeating overhead with a checkable outcome is the highest-value territory there is. Repeating goal skills are precisely what you keep — and where you use the tutor modes instead.

The escalation ladder

Now put each candidate on a rung. This is the structural conclusion of the whole sphere:

Worked twice — save it. Every day — make it permanent. Checkable — automate it.

One-off. Just do it in a chat. Don't build anything.

Worked twice → a saved prompt. The second time you type roughly the same brief, it belongs in your library. Cheap to make, immediately reusable.

Daily, or shared with others → a standing instruction. Personal preferences, a project workspace, or a file inside the project. Stop re-laying the desk by hand.

Repeating, mechanical, with a machine-checkable finish line → an agent. Small reversible scope, plan approved first, the diff reviewed after.

Most people never leave the first rung. Climbing one step per month is a completely reasonable pace, and after a year the difference is not subtle.

Where to stop

Over-automation is a real failure with recognisable symptoms. Any of these means you've gone one rung too far:

• Checking costs more than doing. You're auditing, not delegating.
• You don't understand the output. You've moved the risk somewhere you can't see it.
• Failures are silent. Nothing tells you when it went wrong — the most dangerous configuration, because it's stable right up until it's expensive.
• A goal skill has quietly moved. You reach for the model before attempting, on the thing you meant to be good at.
• The setup needs maintenance you don't do. Rotten standing instructions are worse than none.

The cure is always the same: drop back a rung. That isn't a retreat; the ladder has a correct height for each task, and it isn't always the top.

What stays yours

No configuration changes these, at any level of capability:

Judgement. Reasoning can be outsourced; deciding cannot, because there's nobody on the other end to take responsibility for it.

Taste for your specific audience. The model's output is the median. The value of your work is the deviation, and only you know which deviation is right.

Knowing what's worth doing at all. The model answers the question you asked. Whether it was the right question is not a question it can be given.

Relationships and their consequences. What to say to a person who's upset. What promise you can actually keep.

Not going stale

The tools will change faster than you can track. Fortunately the two layers age very differently.

What will go stale: specific features, product names, modes and their toggles, context limits, prices, which model is best at what, what "it can't do yet". Some of this will be wrong within months.

What won't: it produces a plausible continuation, not a retrieved answer. It knows only what's on the desk. Confidence is a style, not evidence. Examples beat descriptions. The first answer is a measurement. Verify by cost of error. Don't delegate what you can't evaluate. Your move first. These are consequences of the mechanism, and the mechanism isn't what's changing quickly.

Which gives one maintenance habit worth keeping: once a quarter, re-test one assumption about what it can't do. People calibrate on a failure from eighteen months ago and never revisit it — and then confidently explain that AI can't do a thing it has been doing for a year. The mechanics you learned here will still be true. The frontier will have moved.

Where to go from here

This sphere sits in Foundation for a reason: it's a lever on everything else. The most productive next step is not more AI content — it's applying these habits inside a sphere where you're actually trying to get somewhere. Take the tutor modes into whatever you're studying. Take the verification ladder into anything you publish. Take "your move first" into everything.

And the counterpart is already written: How to Learn covers what happens in your head when the tool isn't there. The two make more sense together than either does alone — one is about the leverage, the other about what you're levering.

Check yourself

Close the article and answer in your own words:

1. What are the three questions, and which rule sits under all of them?
2. How do you find the highest-value candidates for delegation in your own week?
3. Name the four rungs of the escalation ladder and what moves a task up one.
4. Name three symptoms of over-automation and the standard cure.
5. What are the four things that stay yours regardless of capability?
6. Which parts of this sphere will go stale, which won't, and what maintenance habit follows?

In short — the whole sphere in twenty lines

How it works

1. The model doesn't retrieve an answer — it rolls to one.
2. The model knows exactly what's on the desk — and nothing else.
3. Don't ask whether you're right. Ask where the hole is.
4. The model has no blank cell. Only a filled one.

How to talk to it

5. Every decision you don't make, the model makes for you — and it makes it by rolling to the average.
6. Three examples beat three paragraphs of description.
7. The first answer isn't the result. It's a measurement.
8. The answer text is the model's scratch paper. Don't take it away.

Trust and verification

9. It has read everything and seen nothing.
10. Don't check the answer. Check its checkable points.
11. Pasted means sent. You can't take it back.
12. Your move first, then its move.

Everyday work

13. A bad tutor explains. A good one asks.
14. Hand over the text and you hand over the thinking. Hand over the work around the text.
15. Don't paste code you can't explain.
16. Ask the document, not the model.

Beyond the chat

17. The model still only writes text. Some of that text now gets executed.
18. Don't explain again — lay the desk once.
19. An agent is a model whose feedback loop has closed.
20. Worked twice — save it. Every day — make it permanent. Checkable — automate it.