The Agentic Engineering Stack: How to Ship 100x Faster
Mickey, a senior developer who generates 95% of his code with AI, walks through his exact workflow for shipping software 100x faster. The key: use Cursor as your harness, pair it with best-in-class models (GPT-5.5 or Claude Opus 4.7), leverage open-source tools like the `opensource` package to inject real code context, structure your codebase meticulously after each feature, and run automated code review loops with Greptile. Success requires staying in control, thinking hard about context engineering, and treating AI like a very smart but literal junior developer—not a replacement for human judgment.
The Harness Matters More Than the Model
What is a Harness?
A harness is the wrapper around an AI model—APIs, tools, system prompts, and markdown files that guide the model to specialize in a specific action. The model itself is just a text predictor; the harness gives it the ability to read files, search, and execute tasks. Different harnesses (Cursor, Claude Code, Windsurf) produce different results with the same model.
Cursor is the Best Harness (If You Can Afford It)
Cursor outperforms Claude Code and other competitors in benchmarks run by actual developers. It lets you switch between models seamlessly and has a strong agentic view. The downside: Cursor doesn't subsidize like OpenAI or Anthropic, so it costs more, but Mickey considers it the best investment for serious agentic engineering.
Model Choice: GPT-5.5 for Complex Codebases, Opus 4.7 for UI
GPT-5.5 Extra High excels at understanding large, complex codebases and architecture. Opus 4.7 Max is better for UI and frontend changes. Despite some calling Opus 4.5 'Slopus,' it remains solid for specific tasks. The model matters, but only if paired with the right harness.
Context Engineering: The Make-or-Break Skill
Keep Context Minimal and Precise
A 227k context window doesn't mean the agent stays smart across all of it. The more you bloat the context, the dumber the agent becomes. Stay in a sweet spot by giving the agent only the exact snippet it needs. This is why agentic engineering beats 'vibe coding'—you do the thinking, then let the agent execute.
Use the `opensource` Tool to Inject Real Code Context
The `opensource` package (by Vercel, open-source) fetches the actual source code of any package or library you're using and dumps it into your codebase. Instead of relying on human-written docs or RAG, you give the agent the single best source of truth: the code itself. Reference it in your prompts with tags like 'reference the Daytona codebase.'
Plan Features in Small, Reviewable Chunks
Don't let the agent plan everything at once. Create a plan yourself, then break it into small PRs and action steps. The agent often dumps everything needed to complete a task into a plan without considering context limits. Small, methodical chunks make it easier for the agent to execute and for you to review.
agents.md Files Are Becoming Obsolete
Modern models like GPT-5.5 and Opus 4.7 are smart enough to read your codebase and infer the tech stack, structure, and patterns without explicit documentation. Only include non-obvious information in agents.md—like project vision, specific constraints, or how to fetch additional source code. Harnesses are getting lighter and thinner.
The Tools and Skills That Multiply Output
Skill 1: Service Layer Refactoring
After building a feature, agents tend to rewrite existing functions instead of reusing them, creating code smell and duplication. A service layer skill structures code so functions can be reused across the codebase. Run this skill after every feature to keep the codebase clean and easy for the agent to navigate on future sessions.
Skill 2: Greptile + Grep Loop for Automated Code Review
Greptile reviews PRs and assigns confidence scores (1–5). The Grep Loop skill makes the agent read the feedback, fix the issues, and resubmit until it reaches a 5/5 score. This automates the entire review cycle. Mickey reports getting 5/5 scores nine times out of ten when PRs are kept small and the codebase is clean.
Why These Tools Work: They Enforce Discipline
These skills aren't magic—they force you to write small PRs, keep context minimal, and structure code well. When you respect these constraints, the agent produces better code, reviews catch real issues, and the loop converges quickly. It's context engineering applied to the entire workflow.
Building the Right Tech Stack for Agents
Choose Frameworks and Tools That Are Code-First
Mickey uses Svelte over React because Svelte syntax is closer to HTML and TypeScript—languages agents excel at. React's hooks and footguns are harder for agents to navigate. Similarly, he uses Convex for the backend because everything in Convex is TypeScript code, not dashboard configuration. Agents get full context on what's happening.
Open-Source Everything (or It Will Become Necessary)
As agents become the primary interface to code, companies building developer tools must open-source their code. Human-written docs are 'the worst, the worst, the worst.' Code is the best context. This is a business imperative: if you want agents to use your tool well, give them the source code.
Inject Source Code Into Your Prompts
When building a feature that uses a library or framework, tag the source code folder in your prompt and ask the agent to reference it. This gives the agent access to best practices and exact function signatures without inflating context—modern models are smart enough to search and find what they need.
The Workflow in Action: From Idea to 5/5 PR
Step 1: Generate the Feature
Use Cursor with GPT-5.5 Extra High or Opus 4.7 Max. Write a precise prompt with context tags pointing to relevant source code. Let the agent build the feature.
Step 2: Test Locally
Run the feature locally to verify it works. This is your first checkpoint—you catch obvious bugs before the agent sees them.
Step 3: Refactor with a Skill
Run a service layer or code structure skill. The agent identifies duplicated code, unused patterns, and structural issues, then refactors them into reusable modules.
Step 4: Run Grep Loop
Submit the PR to Greptile. It scores the code. If not 5/5, run /grep_loop and let the agent fix issues in a loop until it reaches 5/5. You work on something else while this runs.
Step 5: Merge and Move On
Once Greptile gives a 5/5, the PR is ready to merge. The entire cycle—from idea to production-ready code—happens in a fraction of the time it would take a human.
The Mindset: Stay in Control
You Are the Driver, Not a Passenger
Treat the AI like a very smart junior developer with photographic memory but no judgment. You do the thinking—planning, architecture, trade-offs. The agent executes. If you relinquish control, you'll end up with mediocre code and false confidence. Stay in the driver's seat.
Agentic Engineering vs. Vibe Coding
Vibe coding offloads thinking to the agent. Agentic engineering means you think hard, then let the agent do the work. The difference is discipline: small PRs, clear goals, precise context, and ruthless review. This is why Mickey ships 95% AI-generated code without chaos.
The Agent Will Happily Suggest 10 Issues Even If There Are None
Models are agreeable and will generate plausible-sounding suggestions even when they're wrong. You must validate, question, and decide. Don't fall in love with the model or trust it blindly. Treat it as a tool that needs human oversight.
Launch Fast, Iterate in Public
The San Francisco Delusion Is Actually an Asset
In San Francisco, founders believe their product will change the world and launch with barely-functional MVPs. They raise money, hire people, and iterate. Meanwhile, other builders overthink and never ship. The delusion—combined with action—wins. Launch early, get feedback, fix, and ship again.
Your Competition Is Already Shipping
If you're not building in public, your competitors are. They're burning tokens, moving fast, and winning market share even if their product is worse. The only way to compete is to launch early, build in public, and iterate faster than everyone else.
People Want to Try New Things
Most people are bored and actively search for new tools to try. They'll give you feedback, find bugs you missed, and help you improve. Launching with a rough MVP is better than perfecting in isolation. The market will tell you what matters.
Believe in Your Vision, Even If It's Not Perfect Yet
Communicate a vision: 'This is what it is now, but it will be this in the future.' People invest in potential and narrative, not just current functionality. Be delusional enough to believe you can build it, but not so delusional that you ignore feedback.
Security in the Agentic Era
The Threat Is Real and Growing
Models are getting good enough to automate attacks. Distilled models with removed guardrails are available on Hugging Face. The attack surface is expanding. Security is no longer optional—it's critical.
Personal Security: 2FA, Password Managers, and Passphrases
Use 2FA (not SMS—use Google Auth or similar). Use a password manager like 1Password with complex passwords. Share half the recovery key with a trusted family member. Have a family passphrase for voice/video calls (voice cloning is near-perfect now). These are table stakes.
Developer Security: Vet Packages Carefully
The biggest attack vector is malicious packages. Prompt your agent: 'Never install a package younger than 14 days.' By then, vulnerabilities are usually caught. Stay informed on Twitter about new breaches and use Claude to analyze if you're exposed.
Protect Older Family Members
Scammers use AI voice cloning and image generation to impersonate family members and ask for money. Educate older relatives to ask you first before sending money or clicking links. The technology is convincing enough to fool them.
The Future: Knowledge Work Boom, Model Wars, and Mindset Shift
Knowledge Work Is the Bigger Opportunity Than Code
Mickey is more bullish on knowledge work (contracts, accounting, reports, analysis) than agentic engineering. The models are capable; the tooling isn't there yet. OpenAI and Anthropic are launching consulting arms to help companies set this up. Early adopters in their organizations will stand out.
Model Specialization vs. Bigger Models
GPT-5.5 excels at architecture; Opus at UI. The question is: do we build one massive model or smaller specialized ones? Model providers are still figuring this out. Expect competition and rapid iteration.
Opus 5 Could Be the Next Inflection Point
December 4 (when Claude 4 launched) changed the game. Mickey expects Anthropic to release Opus 5 as a similar inflection point to regain market share from OpenAI. Competition drives innovation.
Mindset Shift: This Is Happening For You, Not Against You
Many people dread AI advancement. The winners will reframe it: 'This is happening for me.' Learn with the tools, pick up new skills, find new opportunities. Whether the industry booms or busts, the people with the right mindset will win.
Being 'Non-Technical' Is No Longer an Excuse
Everything will be technical. AI will be everywhere—software, robots, drones. Saying 'I'm not technical' is saying 'I'm the past.' The barrier to entry is low: grit, mindset, and a $200/month subscription. You don't need to know how to code; you need to be willing to learn and experiment.
The Concrete Stack: What Mickey Actually Uses
Harness: Cursor
Primary IDE for agentic engineering. Allows model switching, has strong agentic view, and integrates tools seamlessly.
Models: GPT-5.5 Extra High + Opus 4.7 Max
GPT-5.5 for complex codebases and architecture. Opus 4.7 for UI and frontend. Both are best-in-class and non-negotiable for serious work.
Tools: opensource, Service Layer Skill, Greptile + Grep Loop
opensource injects real code context. Service layer refactors after each feature. Greptile reviews and Grep Loop auto-fixes until 5/5. Together, they form a complete agentic workflow.
Framework: Svelte (Frontend), Convex (Backend)
Svelte's HTML/TypeScript syntax is agent-friendly. Convex is all code—no dashboard config—so agents have full context. Both are optimized for agentic engineering.
Real-World Impact: Beyond Code
Contract Review: 3x Salary Negotiation
Mickey used Claude to review a 27-page contract. The AI highlighted issues and suggested rebuttals. Result: he negotiated 3x the original offer. Cost: $200/month subscription. Savings: thousands in lawyer fees and negotiation gains.
Accounting: Saved $5,000+ in Two Hours
Mickey's accountant quoted $5,000–6,000 to redo 2024–2025 accounting for 3,000 transactions. He used Claude Code with the accounting software API to automate it in two hours. Cost: $200/month. Savings: $5,000+.
Career Acceleration: From Individual Contributor to Manager
A 24-year-old showed his company how Claude Code could automate contract review and legal work. They made him a manager. The lesson: demonstrating AI's value in knowledge work fast-tracks career growth.
Notable quotes
95% of the code that I've created was generated by AI. — Mickey
The model doesn't think. The model just predicts the next text. — Mickey
You have to launch early. Your competition is already shipping. — Mickey
Action items
- Set up Cursor with GPT-5.5 Extra High or Opus 4.7 Max as your primary harness.
- Install the `opensource` package and use it to inject source code of libraries you depend on into your codebase.
- Create an agents.md file with only non-obvious information: project vision, constraints, and instructions for fetching source code.
- After building each feature, run a service layer refactoring skill to eliminate code duplication and structure code for reuse.
- Use Greptile for code review and run /grep_loop to automatically fix issues until you get a 5/5 score.
- Break large features into small PRs (under 50–60% of a feature per PR) to keep context minimal and reviews focused.
- Choose frameworks and tools that are code-first (e.g., Svelte over React, Convex over dashboard-based backends).
- Enable 2FA (not SMS) on all critical accounts; use a password manager like 1Password.
- Prompt your agent: 'Never install a package younger than 14 days' to avoid malicious packages.
- Launch your product early with a barely-functional MVP; iterate in public based on feedback.
- Stay in control: do the thinking, let the agent execute. Validate all suggestions before shipping.
- Invest in a $100–200/month subscription to best-in-class models (GPT-5.5, Opus 4.7) if you're serious about agentic engineering.
- Use Claude or ChatGPT to analyze contracts, accounting, and knowledge work—not just code.
- Build in public and share your progress on Twitter to stay informed and attract early users.