AI does the heavy lifting. I own the outcome.
I treat AI agents like a fast, capable team. I set the goal and the boundaries, they do the work in parallel, and nothing counts as done until it is proven on the real thing.
- Main tools
- Claude Code, Codex, Cursor
- Built on
- My own skill library
- Rule
- Evidence before "done"
- Proof
- EasyFound, this website
Speed with control
My working style lives in a skill called system-retro, which every agent loads before it plans anything. It is my mindset, written down so AI can follow it.
- I keep the decisionsValue, scope, authority and risk stay with me. Agents choose how to implement, test and sequence the work inside that boundary.
- Done means it works for the real userA stub, a mock-only test or a feature that quietly does nothing is a failure, not a pass. Claims need evidence.
- Cheapest route that still meets the barI pick the least costly way to reach the required evidence. Saving cost never turns missing evidence into success.
- Every correction makes the system betterFriction and mistakes are captured and fed back into my skills, so the same problem does not happen twice.
Five steps, every feature
1. Brief
I write the goal, flows and non-goals as a short web page. I confirm it, and it is frozen before anyone builds.
2. Design
One design pass grounded in the real code, then one independent review round. Only important findings are fixed.
3. Build gate
Agents build in parallel. The integrated result must pass build, lint, typecheck and tests, plus one code review and one security review. Issues are fixed by class, at the root.
4. Acceptance
An independent tester (Codex in a real browser) uses the product like a customer. Defects go back, get fixed, and the run restarts until two runs in a row are clean.
5. Handoff
A short note: what was built, what was tested, what is left, and what I need to decide.
A feature moving through the pipeline
How the agents are organised
For technical readers: who does what, and the rules that keep parallel agents from stepping on each other.
Every agent gets its own branch
Parallel workers each run in an isolated git worktree. Only the coordinator merges, and only one PR goes to main per task.
The right model for the job
Claude coordinates and builds, Codex runs browser acceptance and adversarial reviews, Cursor takes small well-defined tasks. Same platform by default, switching only when I choose.
Guard rails, not trust
Git writes go through a guard script, secrets are off limits, and new dependencies, merges or anything external need my approval.
A library of skills
Reusable skills cover each stage: PRD writing, solution design, backend and frontend development, QA acceptance, browser UAT, behaviour inventories, documentation and review standards.
EasyFound is a complete platform that used to need a team, or a full year of one person's time. I built it alone, working this way.
This website was built the same way too: Claude wrote and tested the code, Codex generated the illustrations, and every change was checked in a real browser on desktop and phone before it shipped.
Why this matters to you
- Work that used to need a team, delivered by one accountable person
- Faster timelines without skipping review or testing
- Every "done" backed by a real test, not a promise
- Clear, short updates and decisions only when they matter
