Why This Dev Ships 100x Faster Than 99% of Engineers

TL;DR

Mickey — a senior dev who has AI write 95% of his code — isn't typing prompts into a chatbot; he runs a tight, repeatable pipeline. The model is just a next-text predictor; the harness (Cursor + a best-in-class model) is what turns it into an engineer. He feeds it the single best source of truth — code, not human docs (pulling real package source into the repo and pointing the agent at it), keeps context minimal ("bloat = dumber"), plans first for himself to hold the agent accountable, cleans structure with a skill after every feature, and runs a review loop (Greptile "Grep Loop") that iterates until the PR scores 5/5. The through-line: agentic engineering = you do the thinking; the agents (cracked juniors that need guidance) do the work.

Key takeaways

• The harness matters more than people think. A model can't think or do — it predicts tokens. The harness (APIs, tools, system prompt, agent.md) wraps and specializes it. A great harness maximizes a great model; that's why Cursor ≠ Claude Code ≠ Codex even on the same model.
• Chase the model, per job. GPT-5.5 (extra-high) for large/complex codebases; Opus 4.7 Max for UI/frontend. Best-in-class only — local/cheaper models "won't write code like this."
• Harnesses are getting lighter — "this is why Pi has been winning." Models are good enough that you don't need heavy scaffolding or even agents.md; just tell it the non-obvious (vision, structure).
• Code is the best source of truth. Pull real package source into the repo (Vercel's open-source) and tell the agent to reference the codebase — exact function, no guessing, ~8/10 spot-on. No RAG/vector indexing; models search well, just point them.
• Context engineering is make-or-break. Keep it lean — the more you bloat the window, the dumber it gets. This is why agentic engineering beats vibe coding: you keep the thinking.
• Plan first — for you, not the agent. The plan holds the agent accountable across parallel threads; break big tasks into small, reviewable PRs (models don't budget their own context when planning).
• Structure after every feature (a skill). Agents rewrite instead of reuse → code smell. A "service-layer" skill refactors into reusable functions so the next session isn't confused. (Old engineering hygiene — clean structure, tests — turns out to be great for agents.)
• Close the loop. Greptile scores PRs x/5; the "Grep Loop" skill reads the review, fixes, re-requests, and won't stop until 5/5 — Karpathy's auto-research loop, applied.
• Stay in the driver's seat. Treat the model as "a dumb genius with photographic memory that doesn't know how to use what it knows." Human approval still matters — which is exactly how you stand out.

---

Model vs harness (the thing most people miss)

flowchart LR
    M["🧠 The model<br/>just predicts the next token<br/>— can't think, can't do"] --> H["🔧 The harness (wrapper)<br/>APIs · tools · system prompt · agent.md"]
    H --> R["A specialized agent that can<br/>read files, search, run commands, ship"]

"A great harness maximizes the output of a great model — that's why the same model feels different in Cursor vs Claude Code."

Code is the best context (not human docs, not RAG)

flowchart LR
    P["Package you depend on"] -->|"pull real source into repo<br/>(open-source)"| C["repos/…/the actual code"]
    C -->|"'reference the codebase'"| A["Agent finds the exact function<br/>no guessing · ~8/10 spot-on"]
    D["❌ Human-written docs / RAG / vector index"] -.->|"worse source of truth"| A

Corollary: prefer codified tools the agent handles well — e.g. Svelte (HTML + TypeScript at its core, fewer footguns than React hooks) — and back-ends where everything is code (Convex). Dev-tool companies should open-source, because code is the context.

The build → structure → review loop

flowchart LR
    PLAN["1 · Plan (for YOU)<br/>small chunks, accountable"] --> BUILD["2 · Build feature<br/>Cursor + best-in-class model<br/>+ referenced code"]
    BUILD --> STRUCT["3 · Structure skill<br/>refactor to reusable service layer"]
    STRUCT --> REVIEW["4 · Greptile review<br/>confidence score x/5"]
    REVIEW --> LOOP{"5/5?"}
    LOOP -->|"no"| GREP["/grep-loop: read review → fix → re-request"]
    GREP --> REVIEW
    LOOP -->|"yes"| DONE["✅ Merge — feature done"]

Vibe coding vs agentic engineering

flowchart LR
    V["Vibe coding<br/>offshore the thinking to the agent"] --> VR["🎲 unpredictable, hard to trust"]
    E["Agentic engineering<br/>YOU think · agents are guided 'cracked juniors'<br/>just-enough tools + just-enough context + a feedback loop"] --> ER["✅ the feature is done when the loop ends"]

Strip the guardrails — no referenced code, no structure, no plan, just a loop — and you get Ralph Wiggum: it runs forever and goes nowhere. The guardrails are the engineering.