How do you build mission-critical software with AI without losing control of the architecture? In this episode, Ran Aroussi returns to share his hands-on approach to AI-assisted coding, revealing why he never lets the AI be the architect, how he uses a mental model file to preserve institutional knowledge across sessions, and why the IDE as we know it may be on its way out.

Vibe Coding vs AI-Assisted Coding: The Difference Shows Up When Things Break

“The main difference really shows up later in the life cycle of the software. If something breaks, the vibe coder usually won’t know where the problem comes from. And the AI-assisted coder will.”

Ran sees vibe coding as something primarily for people who aren’t experienced programmers, going to a platform like Lovable and asking for a website without understanding the underlying components. AI-assisted coding, on the other hand, exists on a spectrum, but at every level, you understand what’s going on in the code. You are the architect, you were there for the planning, you decided on the components and the data flow. The critical distinction isn’t how the code gets written—it’s whether you can diagnose and fix problems when they inevitably arise in production.

The Human Must Own the Architecture

“I’m heavily involved in the… not just involved, I’m the ultimate authority on everything regarding architecture and what I want the software to do. I spend a lot of time planning, breaking down into logical milestones.”

Ran’s workflow starts long before any code is written. He creates detailed PRDs (Product Requirements Documents) at multiple levels of granularity—first a high-level PRD to clarify his vision, then a more detailed version. From there, he breaks work into phases, ensuring building blocks are in place before expanding to features. Each phase gets its own smaller PRD and implementation plan, which the AI agent follows. For mission-critical code, Ran sits beside the AI and monitors it like a hawk. For lower-risk work like UI tweaks, he gives the agent more autonomy. The key insight: the human remains the lead architect and technical lead, with the AI acting as the implementer.

The Alignment Check and Multi-Model Code Review

“I’m asking it, what is the confidence level you have that we are 100% aligned with the goals and the implementation plan. Usually, it will respond with an apologetic, oh, we’re only 58%.”

Once the AI has followed the implementation plan, Ran uses a clever technique: he asks the model to self-assess its alignment with the original goals. When it inevitably reports less than 100%, he asks it to keep iterating until alignment is achieved. After that, he switches to a different model for a fresh code review. His preferred workflow uses Opus for iterative development—because it keeps you in the loop of what it’s doing—and then switches to Codex for a scrutinous code review. The feedback from Codex gets fed back to Opus for corrections. Finally, there’s a code optimization phase to minimize redundancy and resource usage.

The Mental Model File: Preserving Knowledge Across Sessions

“I’m asking the AI to keep a file that’s literally called mentalmodel.md that has everything related to the software—why decisions were made, if there’s a non-obvious solution, why this solution was chosen.”

One of Ran’s most practical innovations is the mentalmodel.md file. Instead of the AI blindly scanning the entire codebase when debugging or adding features, it can consult this file to understand the software’s architecture, design decisions, and a knowledge graph of how components relate. The file is maintained automatically using hooks—every pre-commit, the agent updates the mental model with new learnings. This means the next AI session starts with institutional knowledge rather than from scratch. Ran also forces the use of inline comments and doc strings that reference the implementation plan, so both human reviewers and future AI agents can verify not just what the code does, but what it was supposed to do.

Anti-Patterns: Less Is More with MCPs and Plan Mode

“Context is the most precious resource that we have as AI users.”

Ran takes a minimalist approach that might surprise many developers:

• • Only one MCP: He uses only Context7, instructing the AI to use CLI tools for everything else (Stripe, GitHub, etc.) to preserve context window space
  • No plan mode: He finds built-in plan mode limiting, designed more for vibe coding. Instead, he starts conversations with “I want to discuss this idea—do not start coding until we have everything planned out”
  • Never outsource architecture: For production-grade, mission-critical software, he maintains the full mental model himself, refusing to let the AI make architectural decisions

The Death of the IDE and What Comes Next

“I think that we’re probably going to see the death of the IDE.”

Ran predicts the traditional IDE is becoming obsolete. He still uses one, but purely as a file viewer—and for that, you don’t need a full-fledged IDE. He points to tools like Conductor and Intent by Augment Code as examples of what the future looks like: chat panes, work trees, file viewers, terminals, and integrated browsers replacing the traditional code editor. He also highlights Factory’s Droids as his favorite AI coding agent, noting its superior context management compared to other tools. Looking further ahead, Ran believes larger context windows (potentially 5 million tokens) will solve many current challenges, making much of the context management workaround unnecessary.

About Ran Aroussi

Ran Aroussi is the founder of MUXI, an open framework for production-ready AI agents, co-creator of yfinance, and author of the book Production-Grade Agentic AI: From brittle workflows to deployable autonomous systems. Ran has lived at the intersection of open source, finance, and AI systems that actually have to work under pressure—not demos, not prototypes, but real production environments.

You can connect with Ran Aroussi on X/Twitter, and link with Ran Aroussi on LinkedIn.