Skip to content
Phong DuongAI Product Leader

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.

How the work moves My decision Agents doing the work

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

I’ll use this section to show real examples from the work as I can share them.

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.

Memory

Fraimed

Decisions, outcomes, and the context behind them, carried forward.

Explore

Workspace and harness

Sophie

Where I work, and where I control the models, agents, tools, context, and limits.

Explore

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

The models and tools change depending on the work. The preparation and structure around them is what I try to keep consistent.

  • Claude Code
  • OpenAI Codex
  • Open-source LLMs
  • MCP
  • Fraimed
  • Code graphs
  • Git
  • Automated review
  • Structured outputs
  • Python
  • Playwright