The argument in one line.
Agentic engineering replaces vibe coding by keeping humans in control as architects while AI generates 95% of code through harnesses, context tools, service layers, and autonomous review loops that enforce clean structure and measurable outcomes.
Read if. Skip if.
- A developer with 3+ years of experience shipping production code who wants to understand how to architect AI agents into their existing workflow without losing control.
- An engineer currently using Cursor or similar AI coding tools who feels like they're 'vibe coding' and wants a systematic framework to scale from 30% to 90% AI-generated output.
- A technical leader or senior dev evaluating whether agentic engineering is worth the infrastructure investment for their team in 2025-2026.
- You're new to professional development or still learning fundamentals — this assumes you ship production code and understand architecture patterns.
- You're building in a domain with hard regulatory or compliance constraints that require human code review at every step — the autonomous PR loop won't work for you.
- You're philosophically opposed to AI code generation or looking for arguments against it — this is a how-to for believers, not a debate.
The full version, fast.
Vibe coding offloads thinking to the model and produces brittle, bloated code; agentic engineering keeps you as architect while the model does the typing. The method is a stack working in concert: a strong harness like Cursor paired with a top-tier model, the opensrc tool to pull real source code from packages into the repo so the agent reads canonical truth instead of hallucinated docs, a code-structure skill that consolidates duplicated logic into a service layer after each feature, and a greploop that iterates pull requests against an automated reviewer until they earn a five-out-of-five score. Keep features small, contexts lean, and PRs minimal. Ship early, stay delusional, and let tight feedback loops handle correctness.
Chat with this breakdown.
Modern Creator members can chat with any breakdown — ask for the hook, quote a framework, find the exact transcript moment. Unlocks at T2: refer 3 friends + add your own API key.
Create a free account →Who's talking.
Where the time goes.

01 · What is a harness?
Harness vs model: model predicts next token; harness wraps it with tools, system prompts, markdown files. Cursor above Claude Code above Codex. GPT-5.5 xHigh Fast for logic, Opus 4.7 Max for UI.

02 · opensrc: replace docs with the actual repo
Vercel opensrc tool dumps any package source into repos/ folder. Reference codebase in prompts. Agent finds exact functions. Context stays lean via search tools, no RAG needed.

03 · Code structure skill: service layer
After every feature run a service-layer refactor skill. Reusable functions, no duplicated logic. Clean codebase means tight context for next agent session.

04 · greploop: autonomous PR review until 5/5
Push PR, run /greploop, agent reads PR, gets Greptile confidence score 1-5, fixes feedback, loops until 5/5. Ships 9/10 PRs autonomously.

05 · Stack choices optimized for agents
Svelte over React (HTML+TS, no footguns). Convex over Supabase (backend is pure TS code, no dashboard). Open-source libraries: give agent the repo.

06 · Mindset and model investment
Best-in-class models matter. 200 per month subsidized. Autonomous greploop runs prove the ROI. Claude used to negotiate a contract 3x higher.

07 · Launch early, be delusional
SF founders launch half-broken MVPs, raise millions, ship v2. You are still fixing one more feature. Delusion plus belief equals launch equals real feedback.

08 · Cybersecurity in the agentic era
Passphrase for voice clones, 2FA via Authenticator not SMS, password manager, 14-day package rule, paste breach tweet into Claude to check exposure.

09 · Future: knowledge work boom
More bullish on knowledge work than agentic engineering. Tooling lags models. Non-technical is no longer an excuse. Field resets every six months.
Lines worth screenshotting.
- Agentic engineering keeps the human as the architect while the AI writes 95% of the code — vibe coding hands that thinking to the agent entirely.
- The model is just a next-token predictor; the harness wrapping it — APIs, tools, system prompts, agent.md files — is what actually makes it useful.
- GPT-5.5 Extra High outperforms Claude on large, complex codebases while Opus 4.7 wins on UI and frontend changes — use both, swapping by task type.
- Cursor benchmarks higher than Claude Code and Codex for their own models, which surprises most developers who assume the native harness is always best.
- The opensrc context tool fetches package source code directly into the codebase, giving the agent the single best source of truth rather than handwritten docs.
- Harnesses are getting thinner as models improve — modern agents can infer the tech stack from the code itself, making many CLAUDE.md entries redundant.
- The agent.md should only document what the model wouldn't know on its own: vision, specific conventions, non-obvious project structure — not React or TypeScript.
- Greptile's greploop runs autonomous 5/5 PR reviews and is the most underused tool in the senior agentic engineering stack.
- A post-feature code-structure skill that rewrites the architecture after each build keeps the codebase clean as AI-generated code compounds.
- Running multiple agent harnesses in parallel on different parts of a codebase is the real productivity unlock — not prompting a single agent faster.
- The distinction between vibe coding and agentic engineering is not the tools used but who holds the architectural decision-making authority.
- Investing in a great harness returns more value than chasing the latest model, because the harness determines how much of the model's capability actually reaches your output.
Steal the loop, not just the stack.
The greploop is the unlock: an autonomous PR review cycle that runs until the agent earns a 5/5 review score before merging, and it only works because of small PRs and clean service layers.
- Add opensrc to your harness: fetch any thin-docs library repo into your codebase folder and reference it in every prompt instead of guessing from human-written docs.
- Run a code-structure pass after every feature, not for the human, for the next agent session picking it up cold.
- Keep PRs minimal so the review loop can close cleanly; a 100-line PR with a 5/5 score ships faster than a 5000-line PR you are hand-reviewing.
- Pick frameworks where the syntax is familiar model territory (Svelte, not React hooks) and backends where everything is code (Convex, not a GUI dashboard).
- Add the 14-day package rule to your CLAUDE.md so the agent never installs a fresh supply-chain attack vector.
- The field resets every six months; catching up is cheap if you treat non-technical as temporary, not a fixed identity.
Terms worth knowing.
- Agentic engineering
- A disciplined approach to building software where the human directs AI agents as architect and reviewer, providing tight context, plans, and feedback loops rather than handing the entire thinking process over to the model.
- Vibe coding
- A loose, intuition-driven style of building with AI where the developer offloads most thinking to the agent and accepts whatever it produces, with little structured planning or review.
- Harness
- The software wrapper around an AI model — APIs, tools, system prompts, and instruction files — that lets the model take actions like reading files, running commands, or editing code.
- Cursor
- An AI-first code editor that wraps multiple frontier models in a single harness, letting developers switch between providers like Anthropic and OpenAI inside one workflow.
- Claude Code
- Anthropic's command-line coding agent that runs in a terminal, reads and edits files, and executes shell commands as part of its tool set.
- Codex
- OpenAI's coding agent product that runs GPT models against a developer's codebase, available through a subscription that heavily subsidizes usage.
- Tool call
- A structured request an AI agent makes through its harness — like reading a file, running a search, or executing a command — to take action outside of plain text generation.
- Token
- The small unit of text — a word, fragment, or character — that language models read and produce. Models predict the next token in a sequence rather than thinking in whole sentences.
- Context window
- The maximum amount of text an AI model can hold in working memory during a single session. Once it fills up, the model loses earlier information and quality degrades.
- Context engineering
- The practice of carefully shaping what information an AI agent sees — keeping prompts focused, supplying the right source material, and avoiding bloat — to maximize output quality.
- opensrc
- An open-source CLI tool from Vercel that downloads the full source code of a package or repository into your project so an AI agent can reference real code instead of human-written documentation.
- agents.md
- A markdown file placed in a project root to give AI coding agents standing instructions — vision, conventions, or non-obvious rules — that they read before working on the codebase.
- RAG (retrieval-augmented generation)
- A technique where relevant snippets are pulled from a vector database and injected into an AI prompt so the model can answer with knowledge it wasn't trained on.
- Vector indexing
- Converting code or text into numerical embeddings stored in a database so an AI can later search by meaning. Modern agents increasingly skip this in favor of direct file search.
- Slash compact
- A Claude Code command that summarizes a long conversation to free up context window space, letting the session continue without starting fresh.
- Service layer
- A code architecture pattern that consolidates shared functionality into reusable modules so the same logic isn't rewritten across many files — keeping a codebase easier for both humans and agents to navigate.
- Code smell
- Surface-level signs that a codebase is decaying — duplicated logic, sprawling files, tangled dependencies — that make future changes harder even when the code still runs.
- Skill
- A reusable instruction package — typically a markdown file plus optional scripts — that an AI coding agent can invoke on demand to perform a specific structured task, like reviewing or refactoring code.
- Greptile
- An AI code review service that inspects pull requests on GitHub and returns scored feedback, flagging issues with a confidence rating from one to five.
- Pull request (PR)
- A proposed set of code changes submitted for review before being merged into the main project, typically through GitHub or a similar platform.
Things they pointed at.
Lines you could clip.
“Vibe coding offshores the thinking to the agent. Agentic engineering: you do the thinking, then let your minions do the work.”
“The model is a really dumb person with photographic memory.”
“Code is the single best source of truth. Human-written docs are the worst.”
“That belief is why they raised ten million and we are still fixing one more feature.”
“Never install a package younger than fourteen days.”
“Even our thinking changes every six months. Last year we were stuffing the agent with context. Now we do the complete opposite.”
Where the conversation goes.
Word for word.
The bait, then the rug-pull.
Micky Shimeles builds with AI writing 95% of his code and he is an actual engineer. This conversation is the blueprint: the exact harness, the context tools, the feedback loops, and the mindset that separates builders who ship from builders who are still fixing one more feature.







































































