Skip to content
John Frenking
My Process

Structure first, then build with AI as a first class collaborator from concept to production.

Every product on this site went through my same system: an idea gets captured, worked into a real spec, built with AI tools as active collaborators through to launch.

Build System
  1. 01

    Capture

    Back-tap opens Apple Notes, idea gets captured, then the idea gets pasted into Strategy Room Claude Project. It gets routed automatically into either the Signal Log, or the Inbox. Product ideas move straight into Level 1 Discovery.

  2. 02

    Level 1 Discovery

    Is this worth pursuing? Why now, what wave it rides, what V1 does for one person better than anything else? Then IDEA, VALIDATION, and COMPETE documentation gets produced one at a time, requiring approval via human-in-the-loop before moving to the next. Under two hours total, or the idea isn't clear enough yet.

  3. Fork · Kill Point 1

    No shortcut from here to Lean or Production. Conviction alone doesn't skip validation.

    • Kill
    • Continue to Prototype →
  4. 03

    Prototype Lane

    Mandatory for every surviving idea. A PRD covers the one core interaction and the validation signal. Built with no-code tools, Claude Design, or Figma only, no application code at this stage. Shown to at least three real people, reactions logged, then a Signal Log entry: strength, implication, next action.

  5. Fork · Gate P, the only lane fork in the system

    One user acting on their own data stays Lean by default. A second party whose data is genuinely entangled with another's goes Production-Grade, which requires explicit justification.

    • Kill
    • Keep hacking
    • Promote to Lean →
    • Promote to Production →

    The fork splits the product idea into two lanes

    Lane · Lean Product

    Single party path, less data complexity.

    Lean docs, one at a time: PRD, schema, plan, CLAUDE.md. Architecture can be discovered while building, a wrong call in this path only results in patchwork.

    Gate L: kill, keep iterating, or promote if party complexity requires it.

    Lane · Production-Grade

    Multiple entangled parties. Plan completely before build.

    Level 2 Discovery in Product Lab: PRD, user flows, schema, architecture, red team. Then scaffolding, then protocol: complete documentation and a security gate before any build work starts.

    A wrong structural call here is a rebuild, not a patch. That's why it's settled before building, not during.

  6. 04

    Build

    Both lanes build in Claude Code. Lean works straight through its plan's phases; Production-Grade runs the protocol on every feature: discuss, plan, execute, verify, sync. Deploy is the same either way: commit, push, GitHub, Vercel auto-deploy.

  7. 05

    Track & Iterate

    The moment something's live, direct commits to main stop. Every change goes on a branch, gets a preview deploy, gets checked at the data layer, then a PR before it merges. Notion stays the record of what lane, phase, and gate each project is in. Linear runs the actual backlog: cycles, priorities, what's next. Real user feedback lands in one place and gets triaged weekly; concrete requests become Linear issues, softer signals go to the Signal Log.

Supporting Projects

Both ReadAgain and the AI Onboarding Assistant followed this exact process. They were initially captured as loosely defined ideas, planned into real specs, built with AI as a collaborator, and tracked against what was decided. This site went through the same process too, and there's more already in the pipeline.

Three Guiding Principles

  • Structure before code

    Discovery and specs come before implementation, every time.

  • Build AI-native

    AI tools are first-class collaborators in the build, not an add-on.

  • Ship lean, promote deliberately

    Start with the smallest real version; only add complexity when a second party depends on it.