For $165/mo you can ship faster than most senior engineers with 10+ years of experience. This is exactly what I use every day.
I'm CTO @ Nairon, where we're building the Middle East's first AI-forward training programme for experienced software engineers. 60hrs/week, 6 weeks, 100% free, funded by our hiring partners. We identify, up-skill, and deploy the top 2% of engineers into key roles at well-funded companies in the US, UK, and UAE. I'm also Engineer #2 at a startup doing 5 figures MRR pre-launch. Before that I was a Staff Engineer at a Series B that got acquired by a larger enterprise. I've shipped at solo scale, startup scale, and large-team scale. This setup works across all of them. Just copy me.
There's this trend right now of fully autonomous coding. Let the AI handle it all end-to-end. It sounds great until you realize you've lost understanding of your own system and you're burning money on a machine that's confidently shipping bugs.
Degenerately ralphing everything just creates technical and comprehension debt. And it gets expensive fast.
It works for specific things:
- Clear refactoring opportunities where the scope is obvious
- Requirements clarification through structured interviews
- Automated PR creation for straightforward bug fixes
- Prototyping or small internal tools nobody else maintains
But for real feature development in a brownfield codebase? Human-in-the-loop is still the way. Especially as the codebase grows. Rushing full autonomy can cost thousands in lost revenue when critical bugs hit production for millions of users.
I haven't written code by hand in 2 years. I adopted AI-assisted coding long before Cursor existed, so I've watched these systems evolve. We'll keep getting more abstracted from lower-level details over time. That's fine. But it has to be intentional. You and your team need to maintain system understanding as the application changes underneath you.
That's what this framework is for. Maximum AI output, humans still in the loop where it counts.
┌─────────────────────────┐
│ Pre-requisites │
│ │
│ - Claude MAX ($100/mo) │
│ - ChatGPT Pro ($20/mo) │
│ - RepoPrompt ($15/mo) │
│ - Greptile ($30/mo) │
│ - OrbStack (free) │
│ - Zed (free) │
└─────────────────────────┘
│ REQUIREMENTS (25%) │ PLANNING (35%) │ IMPLEMENTATION (15%) │ TESTING + REVIEW (25%) │
│ │ │ │ │
┌───────────────────┐ ┌───────────────────────┐ ┌───────────────┐ ┌──────────────┐ ┌──────────────────┐
│ │ │ │ │ │ │ │ │ │
│ 1. Define high- │ │ 3. Create + Polish │ │ │ │ │ │ │
│ level business │ │ PRD │ │ │ │ 6. Test │ │ 7. Code Review │
│ requirements │ │ (digestable for both │ PRD │ │ │ changes │ │ │
│ │ │ technical and non- │──────>│ 5. Implement │ │ │ │ │
│ Stakeholders │ │ technical folks) │ │ │ │ │ │ Finished │
│ │ │ │ │ │ │ │ │ feature │
└────────┬──────────┘ └───────────────────────┘ └───────┬───────┘ └──────┬───────┘ └──────────────────┘
│ ▲ │ │ ▲
│ Live Calls* │ │ │ │
│ (No Async BS) │ │ │ │
▼ │ │ │ │
┌───────────────────┐ ┌────────┴──────────────┐ │ │ │
│ │ │ │ │ │ │
│ 2. Understand │ │ 4a. Create technical │ │ ▼ │
│ how the current │ │ implementation plan │ │ ┌──────────────┐ │
│ system works │ │ (Architecture, edge │──────────────┘ │ │ │
│ │ │ cases, etc.) │ │ Playwriter │──────────────┘
│ Engineer │ │ │ │ (browser │
│ │ │ Engineer │ │ testing) │
└───────────────────┘ └───────────────────────┘ │ │
└──────────────┘
┌───────────────────────┐
│ │
│ 4b. Create Wireframes│ ┌──────────────────────────────────────────┐
│ / Mockups │ │ As your codebase grows, swap 5 and 6 │
│ (if applicable) │ │ in favor of TDD (/tdd command) │
│ │ └──────────────────────────────────────────┘
│ Figma │
└───────────────────────┘
COMMANDS PER STEP:
1. /ralph-clarify "feature name" (requirements interview)
2. rp-cli -e 'builder "task"' (understand current system)
tldr semantic search "concept" . (find code by meaning)
3. /discovery-interview (PRD from vague idea)
/ralph-clarify "feature" --transcript (PRD from call notes)
4a. /build (generates plan before code)
4b. Figma / v0.dev
5. /build, /fix, /tdd, /refactor (implementation)
6. /test (run test suites)
Playwriter MCP (browser E2E testing)
7. RepoPrompt /review (self-review)
Greptile (automated PR review)
review.fast (quick visual diff)
Merge + Maintain:
/commit (structured commit message)
/describe_pr (generate PR description)
/remember "insight" (store for future sessions)
/recall "topic" (retrieve past decisions)
/onboard (regenerate project ledger)
LEGEND (by impact on output quality):
■ Requirements Clarification — highest impact
■ Planning
■ Review
■ Implementation — lowest impact
*Engineer/s + Stakeholder/s on live calls to shorten feedback loop
This is where most people mess up. Bad requirements in, bad code out. No amount of tooling fixes that.
Get on a live call with stakeholders. Not Slack. Not email. A call. Synchronous communication kills ambiguity 10x faster than async threads. Walk away knowing exactly what "done" looks like.
Before you touch anything, you need to know what's already there and how it works. This is where the tooling immediately pays for itself.
I use RepoPrompt's builder command here. You give it a task description, it looks at the entire file tree and picks the relevant files for you in one shot. Without it, Claude would burn tokens doing 5-10 Grep/Read cycles just to find the right starting point.
rp-cli -e 'builder "understand the authentication system"'
rp-cli -e 'context'
# or search by meaning instead of keywords
tldr semantic search "session token refresh logic" .Context7 (MCP server) pulls up-to-date library docs so Claude doesn't hallucinate API signatures. SuperMemory recalls architectural decisions from past sessions so you're not re-explaining things.
Run /ralph-clarify "feature name" and it starts a structured interview before you write anything. It asks questions you haven't thought of, identifies edge cases, maps dependencies. If you have call notes from stakeholders, you can pass them in:
/ralph-clarify "bulk scheduling v2" --transcript
# paste your Granola/meeting notes afterThe output is a clear picture of what needs to happen, ready for PRD creation.
If you plan well, implementation is just execution. I spend more time here than anywhere else.
Use /discovery-interview to transform a vague idea into a detailed spec, or /ralph-clarify "feature" --transcript if you already have call notes. The goal is a document that both technical and non-technical people can read and agree on. This becomes the source of truth Claude references later.
Now you take the PRD and figure out the architecture. What files change, what edge cases exist, what could break.
# see existing code signatures
rp-cli -e 'structure src/ --max-results 50'
# Claude's /build creates a plan before touching code
/buildContext7 verifies that the APIs you're planning to use actually work the way you think they do (current docs, not 2-year-old training data). SuperMemory pulls in past architectural decisions so you stay consistent.
For UI work, I design in Figma or v0.dev before coding. Taste is developed here, not in the implementation phase.
This is the part everyone obsesses over, but it's actually the smallest chunk of time. With a clear PRD and solid plan, Claude just executes.
The key commands:
/build # plan, implement, test, commit
/fix # investigate a bug, find root cause, fix it
/tdd # tests first, then implement
/refactor # safe refactoring with impact analysisHere's what happens under the hood:
- Claude reads the PRD
- RepoPrompt picks the relevant files
- Context7 checks that library APIs are current
- Continuous Claude v3 orchestrates specialized agents (architect plans, kraken implements, spark does quick fixes)
- Hooks auto-run type-checking and linting after every edit
If you close your terminal and come back later, the memory system recalls what you were working on. Continuity ledger preserves decisions. /recall "feature name" pulls up past context. You don't lose state between sessions.
I use Claude's /test command to run suites, and Playwriter (MCP) to control the browser for E2E testing. Claude can click through UI flows, check state, catch regressions.
As your codebase matures, flip the order. Write tests first, then implement until they pass. The /tdd command handles this workflow.
I use three layers. Each catches different things.
RepoPrompt /review is my self-review before pushing. It understands the full project structure, not just the diff. Catches architectural issues.
Greptile ($30/mo) runs on every PR automatically. Each finding has a confidence score so you can skip the noise and focus on real issues. It understands your codebase, not just the changed lines.
review.fast (free) is for quickly understanding what changed. Visual summaries, fast issue spotting. Good for getting oriented before a deeper look.
/commit # generates a commit message
/describe_pr # writes the PR descriptionThe part most people forget: maintaining understanding as the system evolves. SuperMemory stores architectural decisions permanently. /remember saves insights for future sessions. After major changes, re-index for semantic search:
/remember "auth system now uses JWT with 15min refresh tokens"
tldr semantic index .Each session makes the next one smarter. The system learns with you.
- Zed (editor)
- Claude Code MAX ($100/mo)
- ChatGPT Pro ($20/mo)
- OrbStack (Docker alternative, free)
- Python 3.11+ and uv
- Continuous Claude v3 (see install below)
- RepoPrompt ($15/mo), MCP server + CLI enabled
- Greptile on your GitHub repos ($30/mo)
- review.fast bookmarked
- MCP servers: SuperMemory, Context7, Playwriter
-
tldr semantic index .run in your main repos -
/onboardrun in Claude for each project
git clone https://github.com/parcadei/Continuous-Claude-v3.git
cd Continuous-Claude-v3/opc
uv run python -m scripts.setup.wizardYou need Python 3.11+, uv, and OrbStack running. The wizard is interactive and installs 50 hooks, 114 skills, 12 rules, 32 agents, and 9 MCP servers. After it finishes, run source ~/.zshrc to activate the environment variable.
The system auto-indexes repos on first session. If it doesn't, run it manually:
tldr semantic index .Then search code by meaning:
tldr semantic search "how does payment processing work" .cd Continuous-Claude-v3/opc
uv run python -m scripts.setup.wizard --uninstallRestores your previous config from backup.
TLDR creates .tldr/ and .tldrignore in repos. Ignore them everywhere:
echo -e ".tldr/\n.tldrignore" >> ~/.gitignore_global
git config --global core.excludesfile ~/.gitignore_globalYou (Zed editor)
│
├── Claude Code CLI (claude-opus-4-5)
│ ├── Continuous Claude v3
│ │ ├── 50 hooks (auto-fire on events)
│ │ ├── 114 skills (/build, /fix, /review, etc.)
│ │ ├── 32 agents (scout, kraken, spark, etc.)
│ │ └── PostgreSQL + Redis (memory + coordination)
│ ├── MCP Servers
│ │ ├── SuperMemory (project knowledge) — supermemory.ai
│ │ ├── Context7 (live library docs) — github.com/upstash/context7
│ │ └── Playwriter (browser control) — github.com/remorses/playwriter
│ └── RepoPrompt (context building)
│ └── rp-cli (builder, structure, search)
│
├── TLDR (local code analysis)
│ └── Semantic search (embeddings)
│
└── PR Pipeline
├── Greptile (confidence-based review)
└── review.fast (quick visual diff)