Briefing
We are no longer in the era of "vibe coding." The casual, throw-prompts-at-a-chatbot approach that dominated 2024 and early 2025 has given way to something far more powerful: agentic engineering. This is a disciplined, systematic methodology where human developers act as architects directing fleets of AI agents that write, review, refactor, and ship code autonomously.
In a recent episode of the David Ondrej podcast, Mickey (Ras Mic) - a senior developer who has AI write 95% of his code - revealed his exact workflow. Applications that traditionally take six months are shipping in two to three weeks. Mickey is not a novice offloading thinking to machines. He is a seasoned engineer who has made a calculated decision to embrace where the industry is heading.
"You'd be foolish to not see where we're going," Mickey says bluntly. "The models are not perfect. They're at a point where there are productivity gains, especially if you understand the vertical that you're in."
This article breaks down Mickey's complete agentic engineering stack: the harness, the models, the tools, the context engineering principles, and the feedback loops that enable him to ship at a pace that seems almost mythical to traditional developers.
The Mindset Shift: From Writing Code to Architecting Agents
The first revelation from Mickey's workflow is the fundamental mindset shift. He does not write code in the traditional sense anymore - he architects solutions, designs context, and directs agents.
"In the last three months, all the code that I've created, I'd say 95% was generated by AI," Mickey reveals. He still codes for fun on weekends, but professionally, he has fully committed to the agentic paradigm.
This is not about laziness. It is about recognising that the highest-leverage activity a developer can perform today is not typing syntax - it is thinking deeply about problems, structuring the right context, and guiding agents to execute.
Mickey describes the relationship perfectly: treat your AI agent like "a really dumb person with photographic memory that knows everything but doesn't know how to use everything." The model does not truly think. It predicts tokens. Your job is to give it the right information, tools, and guardrails so those predictions become useful.
Understanding the Agentic Stack: Harness vs. Model
A critical distinction that separates advanced agentic engineers from casual AI users is understanding the difference between the model and the harness.
The Harness Matters More Than You Think
"Believe it or not, the model itself can't do anything," Mickey explains. "The model is just a predictor of next text."
The harness is everything that wraps around the model: the APIs, tool calls, system prompts, configuration files, search capabilities, and UI. It transforms a raw language model into a coding agent that can read files, search repositories, and execute commands.
Mickey uses Cursor as his harness, despite it being pricier than Codex or Claude Code. Cursor lets him switch between models seamlessly, and independent benchmarks show it outperforms Claude Code and Codex even with identical underlying models.
"Cursor, in my opinion, is the best harness," Mickey states. "I can switch between models. Their new agentic view is pretty, pretty nice."
Model Selection in 2026
Within Cursor, Mickey runs GPT-5.5 Extra High for large codebases and architecture work. For UI changes, he switches to Opus 4.7 Max Fast.
This model-chasing strategy is essential. Different models excel at different verticals, and the best engineers deploy the right intelligence for the right task. Mickey is explicit: "If someone says, 'Can I do this with [a local model]?' No, you have to have the best-in-class model. It's a night and day difference."
Local models like Gemma are fine for experimentation but not for production agentic engineering.
The Three Core Tools for 100x Shipping
Mickey's workflow revolves around three interconnected tools that form a powerful pipeline: context injection, code structure enforcement, and autonomous code review.
Tool 1: OpenSource - The Code-as-Documentation Revolution
The first tool is an open-source repository by Vercel literally called OpenSource. It fetches the source code of any package you are using and dumps it into a dedicated folder in your codebase.
Mickey's project contains a folder called opensource/repos/github.com with full source code for packages like Browser Use, Composio, Daytona, and OpenClaw. Instead of relying on human-written documentation - which Mickey describes as "the worst, the worst, the worst" - he gives his agent the actual source code.
"The code is the single best source of truth," he insists.
When building a feature, he tags the relevant folder and tells the agent to "reference the codebase." The agent searches the source, finds the exact functions, and implements them correctly. No guessing. No hallucinated API calls. Modern models are so adept at search that they no longer need the entire codebase indexed via RAG - they just need to know where to look.
Tool 2: Code Structure & Service Layer Skills
AI agents naturally tend to rewrite existing code rather than reuse it. Ask an agent to add Telegram integration to a chat app, and it will likely write a brand-new streaming function instead of reusing the one that already exists. This creates code smell and debugging nightmares.
To combat this, Mickey uses a custom skill that structures code into a service layer - reusable functions called repeatedly across the application. After every feature, he runs this skill to eliminate duplication and enforce clean architecture.
"After every feature that I build, I run one of these," Mickey says. "If the agent needs to work on it again, it's probably written in a way that's going to confuse itself."
He also mentions Matt Pocock's code structure improvement skill as another valuable resource. The principle is simple: messy code is hard for both humans and agents. Clean structure matters doubly in the agentic era because your codebase is the primary context source for future agent work.
Tool 3: Greptile's Grep Loop - The Autonomous Reviewer
The final piece of the puzzle is Greptile, an AI-powered code review tool that Mickey uses for a specific feature called Grep Loop. After submitting a pull request, Greptile assigns confidence scores to the changes - typically three, four, or five out of five.
If the score is less than perfect, Mickey runs /grep-loop. The agent reads the PR, reads Greptile's feedback, implements the fixes, pushes a new commit, and waits for a fresh review. If the new score is still imperfect, the loop continues. It does not stop until Greptile gives a five-out-of-five.
"It will not stop until it gets a five out of five," Mickey explains. "I work on something else, and by the time it's done, almost nine times out of ten, I get a five out of five."
He has watched agents run this loop for twenty to thirty minutes, autonomously fixing issues, pushing commits, and receiving feedback. When the loop completes, the PR is genuinely ready to merge. This is what Andrej Karpathy called the "auto research loop" - applied to production software engineering.
The Power of Context Engineering
If there is one principle underpinning everything Mickey does, it is context engineering. He describes it as potentially "a principle in engineering in and of itself."
The core insight is counterintuitive: less context is often more. A 272,000-token context window sounds enormous, but the more you bloat it with unnecessary information, the "dumber" the agent becomes. You want prompts precise, minimal, and hyper-relevant.
This is why Mickey plans features meticulously before prompting - not for the agent's benefit, but for his own. A well-structured plan helps him hold the agent accountable, identify when the model is fumbling, and break large tasks into small, reviewable chunks.
"In agentic engineering, you're doing the thinking and then you're just letting your minions do the work," he says. "You're letting a bunch of junior grads who are very cracked, but need a lot of guidance, do the work."
This stands in stark contrast to vibe coding, where thinking is offloaded entirely. Agentic engineering demands you stay in the driver's seat, making architectural decisions and guiding execution.
Framework & Backend Choices for Agentic Development
Every choice in Mickey's stack is optimised for agent compatibility. He selects frameworks and backends that are fully code-defined, eliminating any need for agents to navigate dashboards or GUIs.
Svelte Over React
Mickey uses Svelte for front-end work rather than React. Svelte's syntax is fundamentally HTML and TypeScript - patterns AI agents handle exceptionally well. React's newer hooks and patterns act as "footguns" for agents. When the agent needs guidance, Mickey points it to the Svelte source code in his opensource folder.
Convex Over Supabase
For the backend, Mickey uses Convex. Everything in Convex is code - scheduled functions, APIs, database queries, all TypeScript. The only reason to visit the dashboard is production setup or billing.
"The agent has full context on what my backend is doing," Mickey explains. "It's not guessing about the schema."
When everything is code, the agent has complete visibility and can reason about the entire system.
The Feedback Loop That Never Sleeps
The true magic of Mickey's workflow emerges when all three tools work in concert. Here is what the pipeline looks like in practice:
- Context Preparation: He uses OpenSource to fetch the source code of any libraries his feature depends on, giving the agent perfect reference material.
- Feature Development: With a minimal, well-planned prompt, he directs GPT-5.5 Extra High or Opus 4.7 Max Fast to build the feature within Cursor's agentic environment.
- Structure Enforcement: After the feature works, he runs his code structure skill to eliminate duplication and enforce clean architecture.
- Autonomous Review: He submits a PR, gets a Greptile review, and if the score is not perfect, triggers
/grep-loop- then walks away while the agent fixes its own issues. - Test Generation: The best models automatically write comprehensive tests, ensuring that bugs, once fixed, stay fixed.
The result is a development velocity that seems impossible by traditional standards. Mickey is shipping a "pretty big app" that he agent-engineered entirely over three months. When it launches, nobody will believe it was built in that timeframe.
"If I told you I built it in two weeks, three weeks, a month, you would not believe," he says. "But with this exact formula, I've been able to ship like almost anything and everything."
Security in the Agent Era
Mickey does not sugarcoat security implications. "It's cooked," he says bluntly. "We're cooked."
The same tools that fix features autonomously can execute malicious actions too. Distilled models on Hugging Face have had guardrails removed. For developers, Mickey recommends:
- Never install packages younger than 14 days: Give this prompt to your agent directly. Most supply-chain attacks use packages published hours before discovery.
- Use a password manager: He recommends OnePassword, with the emergency key split among trusted family members.
- Enable 2FA - not via SMS: SIM swapping is a real threat. Use authenticator apps instead.
- Establish family passphrases: Voice cloning is near-perfect. Pre-agreed passphrases verify identity over the phone.
- Stay informed on Twitter: Following the right developer accounts ensures you hear about vulnerabilities early.
When a security issue emerges, Mickey pastes the relevant tweet into Claude and asks, "Am I cooked?" The agent scans his system and confirms whether he is safe.
The Launch Mindset: Why Shipping Beats Perfection
Beyond the technical stack, Mickey shares a cultural insight from San Francisco that changed his approach to launching.
"The level of delusion... the level at which people believe they will succeed is so high," he observes. San Francisco builders launch semi-functional MVPs with broken auth, get hype, raise millions, and iterate in public. Perfectionist developers elsewhere spend months polishing features nobody has seen.
"You go on Twitter and look at all those launch videos. You know why they're animated? Because the product barely works. Yet they're launching, they're getting more users, they've got more MRR than me and you."
His advice is direct: launch early, absorb feedback, and iterate. The competition is shipping at light speed while you polish invisible features.
The Future of Agentic Engineering
Looking ahead, Mickey is more bullish on knowledge work than on further engineering advances. The models are already capable enough; what is missing is the tooling. Both OpenAI and Anthropic are launching consulting arms - a signal that the bottleneck is implementation, not capability.
On the engineering side, he anticipates Opus 5 as the next paradigm-shifting moment, similar to how Claude 3.5 Opus changed the game in late 2024.
What is undeniable is that engineering work has permanently shifted. The engineers who thrive in 2026 and beyond will be those who architect the best context, design the tightest feedback loops, and direct their AI agents with precision.
"If you have a simple mindset shift, this stuff becomes fun for you," Mickey concludes. "Don't take the change as this is happening against me. Say this is happening for me."
The tools are here. The models are capable. The only question is whether you have the audacity to ship.
Helpful Resources
Tools & Platforms Mentioned
- Cursor - AI-powered code editor and harness (cursor.com (opens in a new tab))
- OpenSource (by Vercel) - Open-source tool for fetching package source code directly into your codebase - search "vercel opensource" on GitHub
- Greptile - AI code review tool with Grep Loop autonomous feedback feature (greptile.com (opens in a new tab))
- Convex - Code-defined backend platform (convex.dev (opens in a new tab))
- Svelte - Frontend framework optimised for agentic development (svelte.dev (opens in a new tab))
- Supabase - Open-source Firebase alternative (supabase.com (opens in a new tab))
- OnePassword - Password manager for secure credential management (1password.com (opens in a new tab))
- Gemma - Google's local LLM for experimentation (ai.google.dev/gemma (opens in a new tab))
Model Providers
- OpenAI - GPT-5.5 series models (openai.com (opens in a new tab))
- Anthropic - Claude Opus 4.7 series models (anthropic.com (opens in a new tab))
- Hugging Face - Repository for open-source and distilled models (huggingface.co (opens in a new tab))
Community & Learning
- New Society Skool Community - Learn to code with AI (skool.com/new-society (opens in a new tab))
- Scale Software - AI-powered software development, hiring (scalesoftware.ai (opens in a new tab))
- Full podcast notes & resources bundle - All skills, repos, and tools from this episode (davidondrej.com/micky-podcast (opens in a new tab))
Key People to Follow
- Mickey (Ras Mic) on X/Twitter: @Rasmic (opens in a new tab)
- Mickey's YouTube: @rasmic (opens in a new tab)
- David Ondrej on X/Twitter: @DavidOndrej1 (opens in a new tab)
- David Ondrej on YouTube: @DavidOndrej (opens in a new tab)
- Matt Pocock - Code structure improvement skills for agents
- Andrej Karpathy - Pioneer of the auto research loop concept
Related Concepts & Further Reading
- Karpathy's Auto Research Loop - The paradigm that inspired modern agentic engineering feedback loops
- Agentic Engineering vs. Vibe Coding - The critical distinction between systematic AI development and casual prompt-throwing
- Context Engineering Principles - Minimising context bloat while maximising signal for AI agents
- Service Layer Architecture - Structuring code for reusability in agent-driven development
