Every Agentic Engineering Hack I Know
The ten moves that survive contact with production, from running GameTape, Sena, Precis, TrueStandard, and Gavel on agents. Each one backed by a builder who landed on it independently.
Jump to a hack:
The model is almost never the bottleneck. I watched two hundred talks from the AI Engineer stage and ran the same experiments inside my own companies, and the people shipping agents that survive contact with production keep arriving at the same handful of moves. Not one of them is about waiting for a smarter model.
I run five AI-native companies, GameTape, Sena, Precis, TrueStandard, and Gavel, on agents, with a few cofounders and zero hired employees. These ten hacks are what holds up when an agent has to do real work every day instead of demo once. Each one I run myself. Each one has a receipt: a builder who got on stage and described the same pattern from the other side.
They are in build order. If you only take three, take the first, the sixth, and the last: engineer the context, measure with evals, and close the loop.
0
hired employees behind these
5
AI-native companies run on them
15
cron jobs run the loop
59
automated tests gate it
The 10 hacks at a glance
In build order. Each one I run myself, each one with a receipt from a builder who landed on it independently.
Hack 1 · Start here
Engineer the Context, Not the Prompt
The model knows everything public and nothing about your company — curate the context, not a cleverer prompt.
Hack 2
Give the Agent a Computer
A useful agent is a process with a shell, tools, and a file system — not a text box.
Hack 3
Delete Skills Until It Gets Better
More tools and instructions make agents worse — fewer, sharper, non-overlapping skills make them better.
Hack 4
Wire Tools With Skills and MCP
Skills tell the agent how; MCP gives it clean, queryable access to your tools and data.
Hack 5
Give It Decision Traces, Not Documents
Documents make an agent informed; decision traces make it reason like a senior operator.
Hack 6
Make Evals the Unit of Progress
If you cannot measure whether a change helped, you are decorating — write the eval before you scale.
Hack 7
Run Subagents, Not One God-Agent
Decompose the work into specialized subagents — your new bottleneck becomes aligning them, not the model.
Hack 8
Ship Dumb Loops That Self-Correct
A simple loop that runs until it verifies its own work beats a clever graph that shatters when inputs shift.
Hack 9
Run Coding Agents Like a Factory
Stop hand-writing code and manage a factory of coding agents — author becomes operator of the line.
Hack 10
Close the Loop, Keep a Human at the Edge
Feedback loops plus observability plus a human on the few decisions that matter — it compounds while you sleep.
Engineer the Context, Not the Prompt
The model already knows everything public and nothing about your company. The job is not a cleverer prompt. It is curating the right context into a place the agent can query at the moment it acts.
The first time I pointed an agent at one of my businesses, I gave it the docs and the dashboards and watched it make confident, plausible, wrong calls. It was not dumb. It was new. The fix was never a bigger model. It was getting the company-specific context out of my head and into a layer the agent could search.
At Precis that context is thousands of expert sources scored for consensus. At GameTape it is a running history of observations. At Taffy it is transcripts and comments. In every case the work is the same: curate what the agent sees when it acts, instead of stuffing everything into one giant prompt and hoping.
Receipt: Leonie Monigatti of Elastic, in "Agentic Search for Context Engineering," defines context engineering as the art of curating data for the model and shows the shift from a fixed retrieval pipeline to letting the agent search for what it needs. Brandon Waselnuk of Unblocked, in "Stop babysitting your agents," makes the same case: static document repositories fail because they never supply the runtime context, and a bigger context window alone does not fix it.
AI
The next teardown, without checking back
About one a week from the five companies I run with co-founders, AI agents, and zero hired employees — what I changed, and the part that broke.
One click to unsubscribe.
Give the Agent a Computer
A useful agent is not a text box. It is a process with a shell, tools, and a file system it can use.
The agents that do real work in my companies do not just emit text. They run in an environment with a shell, a file system, and tools they can call. The channel-sync system behind this guide is an agent that lists videos, checks a storage bucket, fetches what is missing, and writes files. That is not a chatbot. It is a worker with a desk.
The unlock is to stop treating the model as the product and start treating it as the operator of a computer you hand it. Give it the ability to read, write, run, and check, and most of the prompt wrangling you were doing quietly disappears.
Receipt: Nico Albanese of Vercel, in "Give Your Agent a Computer," wires an agent to persistent sandboxes so it can execute code statefully against a real file system. Monigatti's talk lands here too: she found plain shell and bash tools to be the most versatile primitive she could hand an agent.
Delete Skills Until It Gets Better
More tools and more instructions make agents worse. Fewer, sharper, non-overlapping skills make them better.
My instinct early on was to add: another tool, another instruction, another special case. It made the agents slower and dumber, because every extra option is a fresh chance to pick wrong. The skills in my stack are kept DRY and MECE: one job, one tool, no ten overlapping versions. When an agent is flailing, the fix is almost always to remove, not add.
This is counterintuitive enough that I now distrust anyone whose answer to a flaky agent is "add more rules to the prompt." The legible system wins, and legibility comes from subtraction.
Receipt: Nick Nisi of WorkOS gave a talk titled "How I deleted 95% of my agent skills and got better results," paired with a rule: enforce and measure actions, do not just instruct. David Gomes of Cursor, in "Replacing 12K LoC with a 200 LoC Skill," tore out fifteen thousand lines of worktree-management code and replaced it with one small markdown skill plus a subagent.
Wire Tools With Skills and MCP
Skills tell the agent how. MCP gives it clean, queryable access to your tools and data. Together they close the context gap.
A skill is just a directory: instructions, a couple of scripts, the resources the agent needs, fronted by a short description so the agent knows when to load it. MCP is how the agent reaches your actual tools and data. I keep an internal registry of both, so an agent picks the right tool for the job instead of improvising against a junk drawer of half-connected software.
The reason this matters is blunt: an agent can only reason across data it can query. If your tools are not connected, no amount of model intelligence saves you.
Receipt: Pedro Rodrigues of Supabase, in "Combine Skills and MCP to Close the Context Gap," defines a skill as a folder with a skill.md and front matter, and gives three rules for writing them: do not duplicate your docs, keep mission-critical information inside the skill, and test efficacy with evals across models.
Give It Decision Traces, Not Documents
Documents tell an agent what is true. Decision traces tell it what you did last time and why. The second is what makes it reason like a senior operator.
A pile of documents makes an agent informed. It does not make it wise. What a senior person carries is precedent: why you fired that customer, why the obvious pricing change blew up last time, the five-second judgment they could not explain if you paid them. I capture decisions, not just docs, so the system reasons from what happened before. GameTape is built on exactly this: a longitudinal record of decisions and patterns, not a folder of notes.
Store the why next to the what, and the agent stops repeating mistakes you already paid for once.
Receipt: Zach Blumenfeld of Neo4j, in "Why your agents need decision traces, not just documents," argues agents need precedents and traces, not raw documents, to make context-aware calls. The companion talk "Context Graphs for Explainable, Decision-Aware AI Agents" goes further: encode the business rules and the why, and let the agent learn from past decisions as precedents.
Make Evals the Unit of Progress
If you cannot measure whether a change helped, you are not engineering, you are decorating. Evals are how agentic work earns the word "engineering."
Every important workflow in my stack is gated by evals. Fifty-nine automated tests run before anything ships, and a second model checks each draft against a list the first model never sees, so weak output gets killed before I ever look at it. TrueStandard is this idea turned into a product: a council of models that flags fabricated claims before publish. Without evals you are flying on vibes, and vibes do not survive a model upgrade.
Write the eval before you scale the agent. The eval is the spec.
Receipt: Nick Nisi again, on the power of evals and measurement: simplifying his system only worked because evals told him what helped. Steven Willmott of SafeIntelligence, in "Spec-Driven Testing for Agents," shows that smart is not enough. You test against explicit rules, role permissions, and robustness requirements, not just accuracy.
Run Subagents, Not One God-Agent
One agent doing everything hits a wall. Decompose the work into specialized subagents, and your new bottleneck becomes aligning them, not the model.
When a single agent has to do too much, its context bloats and it degrades. I break work into specialized subagents that hand off. In my content stack, separate agents scout, classify, draft, and check, and the system puts out about forty posts a week with the weak ones killed automatically. The channel pipeline behind this guide is the same shape: one role per agent, run in sequence.
The interesting part is what becomes hard once you do this. It is no longer the model. It is coordination.
Receipt: Lou Bichard of Ona, in "The Missing Primitive for Agent Swarms," lays out swarm and fleet patterns for scaling coding agents, with real deployments at companies like Stripe and Ramp. Maggie Appleton of GitHub, in "One Dev, Two Dozen Agents," names the exact bottleneck I hit: as generation gets cheap, aligning the agents, not raw output, becomes the constraint.
Ship Dumb Loops That Self-Correct
A simple loop that runs until it checks its own work beats a clever orchestration graph that shatters the moment reality changes.
I do not run elaborate branching workflows. I run dumb loops: keep the agent going until it has reflected on, corrected, and verified its own output. Fifteen cron jobs run these loops on a schedule, and a nightly job reads its own transcripts and rewrites the skills. The system is measurably better this month than last, and I did not touch most of it.
Brittle orchestration breaks every time an input shifts. A resilient loop with a verification step at the end just tries again until it passes.
Receipt: Chris Parsons of Cherrypick, in "Ralph Loops: Build Dumb AI Loops That Ship," contrasts fragile visual orchestration with simple loop-based systems that keep running until the work reflects, corrects, and verifies itself. It is the cheapest reliability upgrade I know.
Run Coding Agents Like a Factory
Stop hand-writing code and start managing a factory of coding agents. Your job shifts from author to operator of the line.
I have built fifty-two playbooks and a full content and data stack without hand-writing most of it. The channel-sync skill this guide is built on was authored by a coding agent following a spec, then reviewed. The shift is real: you go from writing code to setting intent, running several agents at once, and checking their work, the way a factory manager runs a line instead of standing at one station.
The guardrail that makes this safe is the same one from hack six: the agent has to verify its own output before it counts as done.
Receipt: Eric Zakariasson of Cursor, in "Building your own software factory," lays out levels of autonomy from autocomplete to fully autonomous, with the agent verifying its work through automated end-to-end tests and the engineer becoming an agent manager. Gary Tan of Y Combinator, in "How to Make Claude Code Your AI Engineering Team," frames the winning structure as "thin harness, fat skills."
Close the Loop, Keep a Human at the Edge
Feedback loops are the whole game. Wrap them in observability and a human approving the few decisions that matter, and the system compounds while you sleep.
An open loop loses information. A closed loop compounds it. Every important action in my companies produces an artifact the system learns from, every run is traced so I can see why it did what it did, and a cofounder signs off on the handful of decisions that need a person. The rest runs on its own. I token-max instead of headcount-max: my model bill is the entire ops team for five companies, and it is a bargain.
This is the hack that ties the other nine together. Context feeds the loop, evals gate it, subagents do the work inside it, and the human stays at the edge guiding the system rather than routing every decision through themselves. If this is the engineering-grade version, the plain-English companion — the five primitives an operator needs to know, ranked — is 5 AI Agent Terms Every Operator Should Know.
Receipt: Mehedi Hassan of Granola, in "Feedback Loops are All You Need," built custom tracing to make the black box visible and concludes that strong feedback loops, not a better model, are what make LLM features work. Liam McGarrigle, in "Human-in-the-Loop Automation with n8n," adds the approval layer for sensitive actions. And "How Google DeepMind Runs Agents at Scale" shows the same instincts at the far end: observability tools and token efficiency are what let agents run at scale.
Frequently Asked Questions
Are these your hacks or a roundup of other people's talks?
Both, by design. Every hack is a pattern I run across my own companies. The receipt under each one is a builder who described the same pattern from the other side. The spine is operating experience; the citations are independent corroboration.
Do I need a big engineering team to run agents like this?
No. I run five AI-native companies on these patterns with zero hired employees, a few cofounders and a stack of agents. Most of these hacks exist to replace coordination and headcount with a system.
What is the single highest-leverage hack here?
Closing the loop, with context engineering underneath it. The model is rarely the bottleneck. The context you feed it and the loop that improves it while you sleep are where the leverage lives.
Will you share the actual prompts and code?
No, by design. This is the set of patterns and the order to build them in. The prompts, skills, and configs are the moat. You get the maps, not the IP.
How do I get this built for my company?
It starts with an audit: a fixed deliverable that maps where your company is overstaffing work a stack of agents could do, and in what order to build it. Apply at agrahri.com.
Want this built for your company?
These ten hacks are how the work gets built. I take a few audits a month: a fixed deliverable that maps where your company is carrying weight a stack of agents could lift, and the order to build your own AI Operating System.
Apply for an audit