You don’t have to trust the AI.
Trust your driving.
DRIVE is a five-step discipline for working with AI. The model you use will change, get faster, get swapped. How you drive it is the part that lasts, and the part you can get better at.
AI made doing cheap. The hard part moved to both ends.
When a draft, an analysis or a block of code costs almost nothing to produce, doing the work stops being the bottleneck. Two things take its place.
Judgement at the front
What is worth doing, and to what standard. Cheap execution makes this the scarce skill — and the one most easily handed over without noticing.
Verification at the back
Whether what came back is actually right. Fluent output reads as finished; the work is telling the difference.
Most advice about working with AI lives in the middle: better prompts, better tools. DRIVE puts its weight on the two ends and hands the middle to the machine. It doesn’t ask you to trust the model. It asks you to trust your practice in relation to it.
Five steps with AI, but not five in a row
Drawn as a list, DRIVE looks like a sequence. In use it has a different shape: one step frames the work, three go round, and one happens afterwards, on the system rather than the task.
Decide frames the loop
You say what done looks like once. Every pass is tested against it, and nothing else ends the work.
Three steps go round
Brief it, steer it as it takes shape, check what comes back. Not there yet? Go round again.
Evolve works on the system
Once the work is done: debrief, then decide where the lesson lives, so the next piece starts better briefed.
It produces unbounded work.
What each step does, and why it works with AI
Each step names a job, a reason it matters when a machine does the middle of the work, and the sign that it has gone missing. Under each are practices from the bank, the same ones the survey’s results page draws on, quoted as they appear there.
Decide
What does “done” mean?
Choose what is worth doing and to what standard, and put what finished looks like into words, before any request goes out.
It keeps the task yours. The standard is set by the person who owns the outcome, not negotiated with a system that will happily keep going. It is also the only thing that tells the loop when to stop.
Missing when the work keeps going round. Each version differs a little, none is obviously finished, and the AI’s next suggestion decides what happens next.
- Write “done” in one sentence. Describe the finished deliverable before you start, and keep that sentence where you can see it.
- Name your standard first. State what “good enough” is before you start, so you notice the moment you’re about to ship below it.
- Reclaim one decision. Pick one call the AI has been making for you and take it back this week.
Request
Intent, context, assumptions, success criteria.
Hand the work over with what you intend, the context it needs, the criteria for done, and the assumptions you are making, said out loud.
Unstated assumptions are the usual root cause of a bad result. Stating them makes them inspectable, so a wrong premise is caught before work is built on it rather than after.
Missing when the result is fluent, plausible and wrong, because it was working without context you assumed it had.
- Brief, don’t defer. Set direction, constraints, and “done” up front (describe intent well) so the AI executes within your frame rather than setting it.
- Ask for the plan first. Ask how it would tackle the task and agree the approach before it starts.
Iterate
Stay in the loop and steer it.
Read what comes back as it takes shape, and redirect it. Not inspect-then-accept: inspect and steer, in a back-and-forth. Even a single chat exchange is this loop.
A short feedback loop keeps trust calibrated. Early, small corrections are cheap; the error caught three steps later has three steps built on top of it.
Missing when the iteration goes quiet and output is accepted on trust, or when the checking never stops. Both are signs the loop has lost its finish line.
- Correct small errors on the spot. Say something the moment you notice a misunderstanding, before the AI builds another step on top of it.
- Test each suggestion against “done”. Hold each suggested next step against the one sentence you wrote about the finished deliverable; if it does not move you toward that, say no.
- Cap concurrency. WIP limits on parallel agent threads. More agents is not more throughput past the point you can hold the overview.
Validate
Confirm against done and success criteria.
The terminal check: does the finished deliverable hold up against the standard set at Decide (tests, figures, ground truth), not just read well?
It anchors trust to evidence rather than fluency. Because the criteria were written first, the check is a checklist, not a fresh judgement every time, and that is what brings the load down.
Missing when the honest summary is: looks right; hope it is.
- Right-size the check. Validation sized to stakes, not applied flat. Read every output against accuracy / suitability / confidence. The higher the stakes, the deeper the check.
- Discount the confident tone. Fluency is not evidence; hear a confident sentence as an unproven claim.
- Check it somewhere else. Take a claim to the real figures, a test, a calculation, a checklist, or a colleague who will disagree.
Evolve
Debrief, then update tooling, context and practice.
After the work: what was supposed to happen, what did, what you would change. Then decide where the lesson goes: your context, your templates, your standards.
It turns one-off corrections into reusable controls. Without it, every piece of work is a fresh transaction and the same mistake is fixed by hand every week.
Missing when you correct the same thing again, or the notes exist but nobody trusts them.
- Fix the memory, and prune it. Correct the durable memory or standing instructions, not only the answer in front of you – and delete any stale rules while you are in there.
- Systematise the win. When something works, capture it as a reusable asset: a template, a saved prompt, a context file. The next run starts from it, not from scratch.
- Test reproduction. Ask: could I redo this without the AI? If not, that’s the debt signal. Close it before it compounds.
Evolve: where working with AI starts to compound
Four of the five steps happen inside a piece of work. Evolve is the one that crosses out of it. Most AI tooling improves loading: getting context into a session. Evolve is about promotion: getting judgement out of one, into a place the next session, and the next person, can use.
1 · Debrief
- What was supposed to happen?
- What actually happened?
- What was right, and what was wrong?
- What would you change next time?
2 · Promote
Decide what the lesson becomes, and how far up it goes.
adding a line means naming the line it replaces.
Promotion doesn’t have to be done by hand. The AI can draft what was learned and where it belongs; a person ratifies it before anything is written. AI drafts, human ratifies, which is what makes promotion cheap enough to actually happen.
What DRIVE looks like in AI co-coding
Software teams have been working this way for a while without calling it anything. The same work, with and without the method:
“Let’s see what we can make.”
- Read code diffs line by line; load rises with volume.
- Vigilance decays as trust, and fatigue, rise.
- Poorly documented code, hit-and-miss results.
- Looks right; hope it is.
- Decide: done = tests pass, and the rationale is in the commit line.
- Request: intent, constraints, precedents and acceptance criteria.
- Iterate: keep realigning with the done state as requested.
- Validate: test the new functionality, and test against regression.
- Evolve: new functionality becomes regression tests; hold a retrospective.
The open question is how to carry these protocols from software into knowledge work in general. That is what the practice bank is for.
Find out how you work with AI today
The AI Co-Working Effectiveness Survey takes about ten minutes. It places you on two axes, how far you keep the call and how far you trust the tool, and names your posture: Vigilance, Partnership, Pragmatism or Execution. A posture is where you and the AI have come to rest at a moment in time, not a verdict, which is why it can move.
Your results page suggests practices from the DRIVE bank, one for each step.
Where this AI method stands today
- A methodology currently being applied by forward-thinking individuals and teams. The five steps come out of research on how people calibrate trust in AI, and out of long-standing disciplines in software engineering and personal effectiveness.
- It converges with what expert early adopters were observed to do. Kam et al. (2025), an occupational study of expert software developers (a panel of eight plus 13 Google advisers), describes many of the same behaviours. That study describes rather than prescribes, and DRIVE was not derived from it.
- Every practice carries its provenance: our own, adapted from a tradition that pre-dates AI, or derived from research that described a behaviour rather than recommended it.
- Thinking is spread across people, tools and records, the idea of distributed cognition (Hutchins, 1995). That is why Evolve cares so much about where a lesson gets written down.
An open bank of AI practices, and it needs yours
Every practice in the bank started as something someone actually does. They have been gathered from published research and practitioners alike.
What makes a good contribution
Something you could fail to do
“Be careful” isn’t a practice. “Write the acceptance criteria before you hand it over” is. You could tell on Monday whether it happened.
Something a good colleague wouldn’t do anyway
The useful habits are the ones you had to learn, usually the hard way.
The work comes out better, or costs less to check
More correct, a better fit, lighter to verify, or it keeps your own skill from wearing away.
Where it came from
What was going wrong before you started doing it. The story is what carries a practice through review.
It is about how you work, not a bug or a feature of a particular tool.
What’s one habit you’ve picked up working with AI?
It takes a minute. Contributions are anonymous; the ones that pass review join the bank, and may be published, without your name, in the open inventory.
Add your one thing Take the survey firstDRIVE: Decide · Request · Iterate · Validate · Evolve. A method for working with AI, 2026. Hutchins, E. (1995) Cognition in the Wild, MIT Press. Kam, M. et al. (2025) What do professional software developers need to know to succeed in an age of Artificial Intelligence? FSE Companion ’25, arXiv:2506.00202.