Opening hook (not on slide): a year ago I was wrong about AI. This is the honest version of what I learned. No agenda slide, open with the tension. ═══ ~44-MIN BUDGET ═══ Open+thesis(1-4) 4 · Ladder+poll(5) 3 · L0-L2(6-9) 5 · L3(10-15) 9 L4 teams+Sauron(16-20) 9 · game(21) 2 · L5(22-25) 5 skip+takehome+close(26-27) 2 · Q&A 5 OFFLINE-SAFE: every demo runs from LOCAL files, no internet needed. - .agnostic-ai/ files (11-15): your own repo, offline. - Game + Konami (21): static HTML, pre-loaded tab. - Sauron (20): pre-recorded Telegram screen-capture; go live only if wifi is solid and tested. Record all three the night before. The 35-min read-through is the hard floor if all media fails.
The "hangover": fast code that looks right but decays fast, and nobody fully understands it. The cost lands weeks later, not in the demo. Thesis of the whole talk: AI drives the speed, you drive the direction. Everything after this is how.
This is the misconception the whole talk disproves: speed and quality look like a trade-off, but they stop being one once you add context and review around the AI.
The idealist trap: I judged AI against perfect hand-crafted code, not against the realistic alternative (rushed code, copy-paste, no tests). Wrong baseline. The fear that turned out overblown: AI ships impressive code that decays fast. True only without the discipline the rest of the talk adds. What changed: I stopped racing AI on output and started directing it, reviewing, constraining, owning the result. The ladder is the framework that came out of that.
Poll the room on something they can answer now (the levels aren't defined yet): who uses AI in daily work? who's banned from it? The map: six rungs, denial at the bottom, orchestrating a team of agents at the top. Every slide from here is one rung up. Self-placement is the payoff: by the close they'll know exactly which rung they're on. We cash that in at the take-home slide, not here.
Shadow IT is the tell: officially "no AI", but half the team still pastes into ChatGPT on personal laptops. The ban doesn't stop usage, it just hides it and removes any review. The real cost isn't a leak, it's compounding time: every month at L0, competitors who adopted pull further ahead. Being honest that you're here is step one.
Same task, same nominal prompt, two engineers, wildly different output. The difference is know-how trapped in each head, never written down. Prompting is the descendant of asking a good Stack Overflow question: the quality of the answer tracks the quality of the question. Speed without shared direction is just faster chaos.
This discipline is the floor that never changes, no matter how high you climb the ladder. "You own every line" is literal: at 2am on call, "Claude wrote it" is not an explanation. Code you can't explain is a time bomb, so push back and simplify until you can.
L1 to L2 is a cultural step, not a technical one, which is why it's the hardest on the ladder. What to write down: shared prompts, conventions, when to push back. Commit it, review it like code. Now AI is a team skill, not a personal habit, so the floor and ceiling both rise and new hires ramp faster. The gap it leaves: shared practices still have no memory. That's what context (L3) fixes.
The trap this avoids: building your whole setup in one vendor's format, then rewriting it when you switch tools. The tool ships next year; your context shouldn't have to. agnostic-ai: define agents, skills, rules, hooks once, sync to 14+ tools in their native format. Bet on the context, not the vendor. DEMO (optional, offline): the WASM playground runs in-browser, pre-load a tab to show a sync.
One folder, committed to git, so everyone who clones inherits the full setup. agnostic-ai syncs it out to each tool's native files (.claude/, .cursor/, copilot, ...). The heart is the root context: the onboarding doc read on every boot. Project = how this codebase works; global = how you work. Every byte ships in every prompt, so keep it short and push overflow to rules/ and skills/. DEMO (~2 min, offline): open the editor, show the real files, the project context, one skill.md, a hook firing on save.
Rules are advice the agent reads when a file matches its glob, it can still drift. Hooks are shell commands the system runs no matter what: auto-format, protect a file, block a commit. Rules are what it should know; hooks are what the system guarantees. Detail worth knowing: the snippet blocks with exit code 2. Exit 1 would NOT block, the edit still proceeds. A deny permission is the hardest line, off-limits even when asked politely.
The accountant beats the genius because expertise is not intelligence. A skill is a markdown file loaded on demand: it costs nothing until one matches. Why they outlast models: the agent is replaceable, your skills are not. New model, productive day one. They encode your domain, conventions, architecture. Where to start: the second time you type the same prompt, that's a skill waiting to be written.
MCP (Model Context Protocol) gives the agent hands beyond your code: filesystem, github, postgres, your own tools. It turns a conversation partner into an active participant. Concrete: ask "which users churned last week", it runs a read-only query and answers, no copy-paste, no leaving the chat. Context says what; MCP lets it act.
The L3 specialist roles (explorer, reviewer, TDD coach, architect) become standing teammates. Org chart unchanged, each person produces more. Right model for the right job: a cheap model to explore, a capable one for architecture. Humans stop racing AI on speed and start directing it.
Start with subagents: simpler, cheaper, easier to debug. One session, focused work, they can't talk to each other. Upgrade to teams when work must run in parallel and share findings, independent sessions coordinating via a mailbox. Teams cost roughly 3x the tokens, so make the parallelism earn it.
Names make coordination legible. Approve the plan once, three background agents launch, each owns a slice: Arwen the DB window function, Elrond the handler limits, Galadriel paging plus tests. They report back as they finish, Galadriel even flagged a failing test before I asked. Independent sessions, shared task list: a team, not a tool. I review and merge.
Same shape as the named team, just more of it. Each agent picks an issue off the task list and runs in its own git worktree: isolated branch, isolated directory, no stepping on each other. Each reads the architecture rules first, follows TDD (red, green, refactor), commits, opens a PR, reports back. I monitor and merge. The parallelism is real, not a demo trick.
A coding agent lives in one repo for one task. Sauron lives in my life: not a tool I open, a place I work. Runs on my own hardware via OpenClaw, always on, no tab to open. I talk to him over Telegram: he reviews PRs, opens issues, ships OSS, and pushes back when I tunnel-vision. More at sauronbot.github.io. DEMO (~4 min, offline default): play a pre-recorded Telegram screen-capture, a real pushback, then Sauron opens an issue/PR. Live only if wifi is solid and tested beforehand; the recording lands the same beat.
Hidden in Sauron's blog: a 9-level Lord of the Rings game. I brought the vision and lore; Sauron brought the craft, rendering, physics, Web Audio, mobile input. 5k lines, two days, I wrote zero code, but every creative decision was mine. Neither of us could have built it alone, that's a co-pilot at its best. DEMO (~2 min, offline): static HTML game, pre-load a browser tab before the talk. Clear a level, trigger the Konami easter egg. Fallback: a local screen-recording.
L4 multiplies output inside the existing structure; L5 changes the structure itself: tickets written so an agent can act on them, reviews that assume part was machine-written, architecture that accounts for what agents do well. A senior IC starts to look more like a tech lead, leading people and agents. Few companies are fully here in 2026, but ignoring the direction is its own decision.
We spent decades making machines faster; now the slowest part of the system is us. Review everything with the same depth and you review nothing with real depth. The asymmetry that forces a new way of working: you can add more agents, you can't add more of yourself. Agents ship 10 PRs while you drink your coffee.
Aviation framing: the plane flies itself, the pilot watches and steps in when something looks wrong. Human-on-the-loop, not hands-on every control. The decision rule, Ship / Show / Ask: ship without review when it's safe, show what you did, ask before big decisions. The danger is automation complacency, so deliberately read diffs you don't strictly have to.
Human-on-the-loop is not a rubber stamp. Spend full review, on purpose, on: security (auth, keys, permissions); irreversible actions (migrations, deletions, money, messages to users); a codebase you're still learning; regulated systems, where "the AI approved it" is not an answer for an auditor. Everything else: a pair-buddy agent as a thinking partner, not a replacement for review.
The most common failure: a team jumps L1 straight to L4. Agents produce mountains of low-quality code because nobody agreed what "quality" means. The agents aren't the problem, the missing foundation is. Order matters: shared practices → context → teams → AI-native. You can't buy your way past the cultural steps.
Three concrete actions, each one move not a concept: (1) locate yourself on the ladder and pick the next step, not the top; (2) write down how your team uses AI (L2) and commit it; (3) extract a skill on the second repeated prompt. Pick one. Bonus tools worth stealing: Caveman trims what the agent says back; RTK trims what the terminal pipes in (same context window, twice the room); agnostic-ai writes your context once and syncs it to 14+ tools. Callback to the slide-5 poll: who'll be one step higher by Monday? Leave this slide up during Q&A (~5 min).
Closing frame: when the hype settles, the question won't be "did you use AI?" but "at what level, and with what direction?" Speed is a gift; direction is a responsibility. More on these ideas: chemaclass.com/tags/ai