Livid Work
← Blog

· updated

Building a prototype with a coding agent, milestone by milestone

A practical workflow for taking an idea to a working proof of concept with an LLM chat and a coding agent — architecture proposal, milestones, and a plan–build–report loop with human sign-off.

  • #ai
  • #coding-agents
  • #llm
  • #workflow

A working prototype used to mean a team of developers and months of work. Today it takes a model subscription and a few evenings — if you drive the coding agent like a technical director rather than a typist. This is the workflow I use.

Models

The tipping point for me was Claude Opus 4.6: before it, model output wasn’t good enough to trust with real code. Opus 4.7 is also good, though I don’t find it much better. More important than the exact version: use maximum reasoning effort. GPT-5.5 is reported to be on par with the latest Opus; I haven’t verified that myself yet.

Prerequisites

  • System thinking. You’ll be looking after the project like a technical director, not a developer. For a personal prototype there’s no time to review every line — what you need is an understanding of software architecture and solid technical intuition.
  • The core concepts. Know what an LLM is, tool calling, structured output, an LLM agent, and multi-agent architecture. Understanding these clearly sets the right expectations for coding agents in general.
  • Access to a strong model. An Anthropic subscription, or any provider that gives you Claude Opus 4.6 or later. A subscription with GPT-5.5 may work too.

The workflow

  1. Shape the idea. Open an AI chat with the most capable model and describe the idea in plain words. It’s not a person — you don’t need to make it interesting, just add every detail that comes to mind. Ask for a summary at the end and actually read it: look for contradictions and weak spots and have the model refine them. Don’t go too deep yet; this is still the general idea.
  2. Pick the stack. Discuss the technology stack — something you’re interested in or comfortable with — and the platform it will run on. Ask for a summary again.
  3. Run deep research on the idea and the stack. Have the model evaluate them, propose better alternatives if any exist, and check everything that bothers you.
  4. Get an architecture proposal. Feed the research result back in and ask for a final project architecture proposal.
  5. Switch to a coding agent. I use GitHub Copilot in VS Code and Claude Code; anything works as long as it runs a strong model at maximum reasoning effort. Initialize the project the way your agent expects.
  6. Commit the proposal. Create ARCHITECTURE-PROPOSAL.md in the project and paste the proposal into it.
  7. Split it into milestones. Ask the agent to break the proposal into milestones, one MILESTONE-X.md file each, plus an EPIC.md that tracks progress across them.
  8. Teach the agent the process. Have it update its own instructions so every milestone goes through the same stages:
    • Planning and investigation — re-check the requirements and write an implementation plan, including a report of the completed work and demo steps a human can run.
    • Development — write the code and tests, and make sure the demo works.
    • Documentation.
    • Report and human sign-off before the next milestone can start.
    • Progress tracking in the milestone and epic files.
  9. Run the loop, one milestone at a time. Clear the context (or start a new chat), switch the agent to planning mode, and ask it to plan the next milestone. Read the plan. Refine it with the agent until you’re satisfied and it contains the stages above, then let it implement. When it’s done, read the report and run the demo steps. If everything works, tell the agent so it updates the progress; if not, work with it until it’s fixed. Repeat until every milestone is complete.
  10. Keep going. You now have a working proof of concept. To evolve it, write the next epic and run the same loop.

Remarks

  • Ready-made frameworks exist that do the same thing in a more sophisticated way — for example GitHub Spec Kit and Superpowers. Building the process from scratch is still worth it once: you see how the agent works through your plan instead of a third-party one.
  • Know your agent’s features — read up on its instructions/rules files and skills.
  • Turn mistakes into rules. When the agent struggles, takes a wrong approach or does something dumb, ask it why, and have it update its own instructions so it doesn’t happen again. Over time this is also how you teach it your preferred style of development.

Originally published on Medium in May 2026 (with help from Claude Opus 4.7 for grammar and structure); trimmed here to the technical part.