Hardcore Agentic Engineering for builders who ship
Greg Ceccarelli
Founder, SpecStory • Ex-CPO, Pluralsight
Jake Levirne
Founder, SpecStory • Ex-CPO, Docker
Driving agents effectively is the engineering skill that matters most right now.
The Transformation:
Stop trusting the green checkmark. Walk out driving agents on real work and proving it before you push.
What you'll do:
Build a real agentic harness in 3 weeks from an initial loop to a verified deterministic gate
Brief the goal, steer the run, verify the result: in class, then on your own repo each week. You'll ship on Demo Day.
Why this matters:
Everyone worries AI makes engineers worse. After two years building entirely with agents, we've found the opposite: a high-ceiling skill is forming: driving agents to produce work, then engineering the proof it's correct.
The split isn't who uses AI; everyone does. It's engineering your mindset, process, and harness versus letting agents ship slop.
Agentic Engineering where the unit of review is a goal, not a diff is a brand-new practice.
The courses that do exist teach the easy part: idea to prototype in minutes.
The hard part: making an agent's code correct, yours to understand, and safe to ship over months is what almost no one can teach, because few have done it for real.
We have, entirely by driving agents (what we build at SpecStory, used by 200K+ engineers). And you'll learn it live in a build room we made: Stoa, not Zoom.
What you’ll learn
Build an agentic harness end-to-end, hands on, and walk away able to brief the goal, steer the run, and verify on your own repo confidently.
Author a capped goal + bounded rider with named checks before any code, so "done" is a check that passes or fails not a feeling.
Compile plain-English "done" into runnable checks the harness runs each turn and compare with model judges.
Build and reuse a custom Agent Skill so Goal Engineering is one repeatable command and judge when a full goal+rider is overkill
Re-derive an agent's "it passed" from what it didn't write with the running binary, the real exit code, the actual bytes.
Stand up a separate gate holding a secret the agent can't read, and watch it refuse a forged "accepted" marker.
Drive an agent to find a real bug in a read-only, zero-edit turn, so you judge its reasoning before you trust the fix.
Kill a wrong run at the first bad move with one asserted fact, instead of debugging a path it already ran down.
Redirect a stuck agent by pointing it at working code and a full SHA range, not by re-explaining yourself in prose.
Read your interrupt rate from your session histories, and feel a runaway coming before it costs you hundreds in tokens.
Write a hand-off doc a stateless agent ships from every claim pinned to a file:line or a re-runnable command.
Send a 20-read investigation to a side-agent that returns only a summary, keeping your main window out of the 40% "dumb zone."
Keep an AS-BUILT map per subsystem and durable state in files, not chat, so a crash or fresh context window loses nothing.
Develop judgement to distinguish between what Claude or Codex is best at, what effort to use, when to use a goal, workflow or agent team.
Fan out across git worktrees in look-don't-touch lanes that can't collide and know when parallel agents add intent and cognitive debt.
Apply a semantic rebase. Delete and regenerate a tangled branch from a clean base, lessons kept, instead of patching the mess.
Learn directly from Greg & Jake
Greg Ceccarelli
Co-Founder, SpecStory • Ex-CPO Pluralsight • Data at GitHub, Dropbox & Google
Jake Levirne
Co-Founder, SpecStory • Ex-CPO Docker • Product at Digital Ocean, YesWare & IBM
Who this course is for
Experienced Engineers who need to move beyond prompt & context engineering. You'll learn to brief, steer, verify and own every change.
Product Founders whose early velocity vibe coding feels like luck. You'll turn it into a repeatable method that holds up over months.
Seasoned PMs and Tech Leads whose job became spec-writing. Your leverage is actually designing goals and proving results.
Prerequisites
This is NOT a beginner course
You've built and shipped software before. This isn't an intro to coding or AI; we'll move fast and assume pre-existing judgment.
You use a coding agent weekly on real work (and have access to one)
Claude Code, Codex, Cursor, etc on actual projects at work or in OSS. We sharpen how you brief and verify it, not the basics of the tool.
Comfortable with VCS (git) and testing
Tests, commits, branches, worktrees are familiar. We build on these, so class time goes to judgment, not setup.
What's included
Live sessions
Learn directly from Greg Ceccarelli & Jake Levirne in a real-time, interactive format.
The prove-it harness: yours to keep
You don't learn how to drive agents effectively until you build one. By the end you have a real, working agent harness you wrote by hand, from a ~90-line loop to a gate it can't bribe (M0–M12): it runs in a sandbox, survives a kill -9, and refuses a faked "done." Most courses hand you slides. You walk out with a tool you can keep improving forever.
We take the "Hardcore" part of the title seriously
Hardcore means hands-on for builders ready to raise their ceiling, built together from a starter. You'll write a real agent loop, cage live agents, and stand up a gate the agent can't bribe. Prototypes in minutes are the easy part. The hard part correct, yours, safe to ship over months is the level-up you leave with.
Free access to Stoa
Full cohort access to Stoa (withstoa.com): the collaborative build room and version control for coding agents we run the whole course inside. It's not a video grid: you share plans, proofs, and sessions in the same place you build. And it's the real product we built by driving agents the way this course teaches so you learn inside the proof.
8+ Hours of Office Hours, ontop of live sessions
Two standing sessions every week beyond the live builds: a Wednesday 2-hour build-alongside where we debug your harness live, and a Friday-morning ship-it clinic to land your weekly project. Most courses offer vague "office hours" these are structured and twice weekly. Bring what's broken; you leave with it fixed, not a reading list.
Cohort Peer Pods
You're placed in a small pod for the whole cohort: swap PROOF.md files, critique each other's briefs, and ship together. Unlike most courses, we're targeting those who already ship with agents, so feedback comes from practitioners that you can learn from. It can live in Stoa, our build room, not a chat-server graveyard, so your work is seen.
Lifetime access
Go back to the recordings, slides, starter code, and real artifacts whenever you need: for life, plus every update to future cohorts. The builds are dense; most students will re-watch to catch lines they missed. This is the rare course that gets more valuable the second time through, because you watch it with a harness you've already built.
Certificate of completion
A certificate to share with your employer or on LinkedIn. But the real credential is what you'll have built: a working harness and a one-page PROOF.md you can put in front of a team and say, "here's how I drive agents, and here's the evidence it works."
Maven Guarantee
Your purchase is backed by the Maven Guarantee.
Course syllabus
10 live sessions • 12 lessons • 3 projects
Week 1
Week 1: Build it, then break it
Aug
4
⚡ Live Session 1: Tue Aug 4 · 5–7pm ET — Build a tiny agent, then make it lie
Aug
5
Optional: 🏢 Office Hours Week 1 · Wed Aug 5 · (2 hr)
Aug
6
⚡ Live Session 2: Thu Aug 6 · 5–7pm ET — Cage it, then steer it.
Weekly Project
Week 2
Week 2: Brief it, then gate it
Aug
11
⚡ Live Session 3: Tue Aug 11 · 5–7pm ET —Make the brief do the work.
Aug
12
Optional: 🏢 Office Hours Week 2 · Wed Aug 12 · (2 hr)
Aug
13
⚡ Live Session 4: Thu Aug 13 · 5–7pm ET — The gate it can't bribe, and the handoff.
Weekly Project
Free resource
25 Patterns in Agentic Engineering: the field guide to shipping real software by steering agents.
Everyone teaches idea-to-prototype. Almost no one teaches the hard part: making an agent's code correct, yours to own, and safe to ship.
This 64-page book distills 25 patterns from an eight-month build: 1,310 recorded sessions and 4,670 commits behind Stoa. Every pattern traces to real commits, sessions, or files.
In six parts, you'll learn to brief a goal the agent grades itself against, verify its work against evidence it can't fake, steer a live run, and route models like a team.
A free field guide PDF: the same patterns our course is built on.
Schedule
Live sessions
4-6 hrs / week
Two 2-hour live builds a week (Tue & Thu, 5–7pm ET) where the harness gets built in front of you. Optional drop-in office hours (Wed evening and Friday morning) when you're stuck.
Tue, Aug 4
9:00 PM—11:00 PM (UTC)
Wed, Aug 5
9:00 PM—11:00 PM (UTC)
Thu, Aug 6
9:00 PM—11:00 PM (UTC)
Projects & Async Content
3-5 hrs / week
You'll build an agentic harness across all three weeks to solidify every move you learn. Plan 3 - 5 hrs/week: a short take-home per module on your real repo, plus a weekly proof you submit, peer-review, and demo. The three weeks stack into one capstone you present live on Demo Day.
Frequently asked questions
Maven for Teams
Reimbursement
Get your company to pay
Everything L&D needs: email template, receipts, and certificate of completion.
Get reimbursedTeam discount
Learn with your teammates
Save 20%+ when 2 or more teammates enroll in the same cohort.
Save 20%+ with a teamPrivate cohort
Run a cohort for your org
A dedicated cohort with a custom schedule and curriculum, tailored to your team.
Book a private cohort$1,800
USD