How I work
I don’t start by asking an agent to build.
A lot of the most important work happens before I ask an agent to start building. I usually begin with an incomplete idea and spend time figuring out whether it deserves to become a product at all. If it does, I build a thin slice to test the part I am least sure about, and what that teaches me decides how I proceed.
Only then does the work get structured. Specification, phased plans, acceptance criteria, and the project knowledge that has to stay available while agents are running for hours at a time.
01
Research
is this a product
02
Thin slice
test the uncertainty
03
Specification
behavior and boundaries
04
Implementation
long agent runs, phased
05
Testing
against acceptance criteria
It is not a pipeline. Testing sends me back to the specification often, and sometimes back to the idea.
What this looks like in practice
Placeholder
A long agentic session
Sophie during extended implementation: what was running, what it was working against, and where I stepped in.
Placeholder
Research and product thinking
Early work on an idea: the workflow, what already exists, and the assumptions worth checking.
Placeholder
A thin slice
The first usable version, built to test one uncertainty rather than to ship.
Placeholder
Specification and phased plan
Intended behavior, boundaries, and the phases the implementation was broken into.
Placeholder
Acceptance criteria and results
What the work was supposed to do, and what testing actually showed.
Placeholder
Memory carrying forward
A Fraimed memory bringing an earlier decision into later work.
Before I build
Research, and arguing with the idea.
I spend real time on the idea first. What the workflow actually looks like for the people inside it, where the friction is, what already exists and why it has not solved the problem, and which assumptions I am carrying that I have not checked. Some of that is research. A lot of it is arguing with the idea.
Not everything survives this. Some ideas turn out to be a feature of something else, or a problem people have already stopped caring about. Working that out early is cheaper than working it out after implementation.
What I want from this stage is a clear view of the problem, the product decisions I already know I have to make, and the specific thing about the idea that is still uncertain.
Prove the idea in something real
A thin slice aimed at one question.
I usually do not go straight to the full product. I find the important uncertainty and build a thin slice that is genuinely usable, aimed at that one question. Can the workflow hold together. Does the technical approach work. Does using it actually feel right.
That slice is implementation, but its job is to teach me something rather than to ship. Reading about a workflow and using it are different, and the difference tends to show up quickly once something real is in front of me.
What I learn there decides whether to commit, change direction, or stop.
Structure before scale
Specification, boundaries, and phases that mean something on their own.
Once the slice gives me enough confidence to keep going, the work becomes much more deliberate. I define the intended behavior, the product decisions, the scope, the boundaries, and the acceptance criteria. Larger implementations get broken into phases that mean something on their own.
Each phase needs enough specification and context behind it that an agent can work for a long stretch without stopping to ask what I meant. What I am trying to avoid is the point where it runs out of specification or context and starts filling in the blanks itself.
I also turn the ways of working I repeat into reusable structure for the agents, so the method does not have to be rebuilt from scratch on every project.
Agents execute very quickly, so a vague specification produces incorrect work very quickly too.
Speed on the implementation side raises the value of the preparation.
Keeping agents grounded
The chat window is not the whole environment.
Long-running work needs the project to still be there hours later, and it needs somewhere for decisions to live that is not a transcript.
That problem is a big part of why I ended up building Fraimed and Sophie in the first place. Without that structure, long agent runs turn into constantly rebuilding the project for the agent, or letting it drift away from the product I intended.
Test what was actually built
Acceptance criteria come from the specification, not the implementation.
The work gets tested against the behavior it was supposed to produce. Automate what can be tested reliably. Review by hand the things that need judgment, the product decisions and the way the workflow actually feels to use.
When something fails, the next iteration starts from a concrete finding rather than a general sense that something is off.
The plan is not supposed to be rigid. Working software teaches you things, and the product should change when it does. The difference is whether it changed because I learned something, or because an agent lost the thread and expanded the work on its own.
Tools I use
- Claude Code
- OpenAI Codex
- Open-source LLMs
- MCP
- Fraimed
- Code graphs
- Git
- Automated review
- Structured outputs
- Python
- Playwright