Own What AI Writes
working titleAgents write the code now. You still own every line they ship.
For mid-level and senior TypeScript engineers who approve the pull requests Claude Code, Cursor and Copilot open. You turn your review comments into types, lint rules and tests, so the codebase rejects bad agent code before it reaches you.
Save your presale price
$199 presale price, opening early 2027.
By Petar Ivanov, author of The Conscious React and The Conscious Node. 30K+ engineers subscribe to his newsletter.
Make the settings Save button use the brand color
- features/settings/SaveButton.tsxasked for+2 −2
- features/auth/session.tsnot cosmetic+41 −12
- lib/utils.ts+18 −3
- features/billing/InvoiceRow.tsx+6 −6
- features/profile/ProfileCard.tsx+9 −4
- features/settings/Toggle.tsx+3 −3
- styles/theme.ts+12 −1
- api/client.ts+7 −2
The problem
Three questions you ask about every agent pull request
Each one comes from my DevTalks Romania 2026 talk. If you approve your team's AI pull requests, you have probably asked all three this month.
- Problem 01
Why so much code?
const ProfileCard = ({ user }) => { const name = useMemo(…); const initials = useMemo(…); const joined = useMemo(…); const onEdit = useCallback(…); const onMessage = useCallback(…); const onFollow = useCallback(…); return <div>…</div>;};// six hooks that do nothing You ask for a profile card and get six memoizations that do nothing. Nothing is broken and the tests pass, but every extra line becomes the example the next agent copies.
Module 2 fixes this with less code, where every line needs a reason.
- Problem 02
Why did it touch that file?
// one file asked, eight changed You ask for a change in one file and the pull request touches eight. Most of it is cosmetic. One change sits in a module nobody asked it to go near.
In Module 3 you replace folders with real walls.
- Problem 03
Why didn't it crash?
// the queue grows, the errors stay at 0 A missing timeout, a swallowed error, a default that hides the failure. In the incident from my talk, nothing threw and nothing logged an error. The queue grew for hours until someone noticed.
Loud failures replace silent defaults in Module 4.
- 66%of developers say their top frustration is AI output that is "almost right, but not quite"Stack Overflow Developer Survey 2025
- 3.1%of developers highly trust the accuracy of AI toolsStack Overflow Developer Survey 2025
- +441%longer median time in review on teams with high AI adoption, with pull requests 51% largerFaros AI Engineering Report 2026
Up close
It looks right. It isn't.
Here is problem 3 as code. The first version looks reasonable line by line, and all 12 tests pass.
async function total(id: string) { try { const res = await fetch(url(id)); const data = await res.json(); return data.total; } catch { return 0; }} // total.test.tstest('billing down', async () => { billing.fail(); expect(await total('7')).toBe(0);});async function total(id: string) { const res = await fetch(url(id), { signal: AbortSignal.timeout(5000) }); if (!res.ok) { throw new BillingError(id); } const body = await res.json(); return Invoice.parse(body).total;} // total.test.tstest('billing down', async () => { billing.fail(); await expect(total('7')).rejects .toThrow(BillingError);});You can catch this by reading harder, every time, on every pull request. Or the codebase can refuse it with a lint rule for fetch without a timeout, a type that makes failure explicit and a test that fails when the code is wrong.
AI did not kill software design. It made it more important.
Vibe coding
Ask AI for code, get the code, and ship it because it feels right.
It works for prototypes, small apps and quick fixes, and it isn't stupid. It breaks down once the codebase grows.
Conscious engineering
Ask AI for code, understand the design it ships, and verify the rest.
You build apps that survive growth, scale and change. The course makes this cheap enough to do on every pull request.
The method
Stop writing the same review comment every week
A longer CLAUDE.md only asks the agent. Each rule in this course becomes a type, a lint rule or a test, so the editor and CI reject the mistake before you open the pull request.
// the wall, in the editor and in CI{ files: ['src/features/**'], rules: { 'no-restricted-imports': ['error', { patterns: [{ group: ['**/features/*/internal/**'], message: 'Import the feature from its index.ts.', }], }], 'no-restricted-globals': ['error', { name: 'fetch', message: 'Use apiClient from src/lib/api.', }], },}- TypeThe code does not compile
- Lint ruleThe editor and CI refuse it
- TestThe build fails when the behavior is wrong
- Skill or hookThe agent is stopped or steered
- Prose in AGENTS.mdThe agent is asked, and may not listen
The change
Before and after the course
- Today
The agent writes three times the code the task needed, and the next agent copies it
After the courseLess code. The codebase makes the simple path the default
- Today
Asked to change one file, it changes eight
After the courseReal walls. Module boundaries enforced in the editor and in CI
- Today
It swallows errors, adds silent defaults and writes tests that can't fail
After the courseLoud failures. Strict types, timeouts and tests that fail when the code is wrong
- Today
"Looks fine, tests pass", and then it breaks in production
After the courseProof. The pull request shows it ran against the real app
- Today
You give the same review comment every week
After the courseEach correction is written down once, as a type, a rule or a test
- Today
You feel like the team's proofreader
After the courseYou direct. Every diff you read is a design decision
What's inside
What you'll build, in your own repo
Six modules and a capstone. Each module ends with a change in your codebase, not only in the course repo.
Module 1
AI is a mirror
Find the three patterns in your own last 20 AI pull requests: bloat, changes outside the task, silent failures. Time your reviews as they are today.
Your repo gains: A risk map and a review-time baseline
Module 2
Less code. Every line needs a reason.
The reasons agents over-produce, composition before memoization, one API layer and one data layer, and dead code blocked in CI.
Your repo gains: Less code for agents to copy
Module 3
Real walls. Not folders.
Dependency rules in CI, contracts at the boundaries with Zod and type-safe SQL, and the server and client boundaries in React and Next.js.
Your repo gains: Boundaries that block in CI
Module 4
Loud failures. Not silent defaults.
Strict types, Result types, the timeouts and retries agents leave out, and tests that fail when the code is wrong.
Your repo gains: Agents can no longer swallow errors or widen types
Module 5
Proof before merge
The guardrail layers, a check that drives the running app, and a pull request that arrives with evidence attached.
Your repo gains: An agent opens a pull request with proof
Module 6
You direct now
Read every diff like a design. A review policy built on "never merge what you don't understand", design docs for the next agent, and honest numbers.
Your repo gains: A review policy your team adopts
Capstone
One real feature, inside your walls
An agent builds a feature in your own repo. You review it as a design and compare your review time with the Module 1 baseline.
Presale price: $199
The presale opens in early 2027. After you confirm, my first email brings the Module 1 exercise. It asks you to find the three failure patterns in your last 20 AI pull requests.
Fit
Who it's for, and who it isn't
It's for you if
- You're a mid-level or senior TypeScript engineer
- Your team ships with Claude Code, Cursor, Codex or Copilot
- You approve most of the pull requests, and the queue keeps growing
- You inherited a codebase that agents have been writing
It's not for you if
- You are new to programming
- You want a Claude Code tutorial. The vendors already teach that for free
- Your team doesn't use coding agents yet
- You build AI features into your product. That's a different course
Who's teaching it
Petar Ivanov
I've spent 8+ years building production systems for Fortune 500 companies in cloud, finance and travel, and I've been a startup CEO and CTO. I wrote The Conscious React and The Conscious Node, and I write The T-Shaped Dev every week.
I use Claude Code, Codex and Cursor every day. This course grows out of my DevTalks Romania 2026 talk, and every module opens with an idea from that stage. See the talk.
- 8+years in production
- 2books on architecture
- 30K+newsletter subscribers
- 80KLinkedIn followers
"It is a fantastic and easy read with simple to follow guidelines illustrated with examples. The book has been really beneficial and practical for me from day one."
"Great newsletter to help you level up as an engineer! Petar shares very practical insights in a very detailed and understandable way."
"Petar's book is excellent for React developers at all skill levels and deserves a spot on every React shop's shelf. Each page offers short, simple, and applicable advice."
These are about my books and my newsletter. The course is new, so it has no reviews yet. Readers rate The Conscious React 4.9/5.
FAQ
Questions
When does it open?
The presale opens in early 2027. Waitlist members get an email the day it opens.
What will it cost?
The presale price is $199, and it holds for the whole presale. There is one price, with no tiers.
What if it isn't for me?
You have 30 days to ask for your money back. Email info@petarivanov.tech and I refund you in full, no questions asked.
How are the modules released?
Module 1 is ready the day the presale opens. After that, a new module arrives every two weeks.
Is this a Claude Code tutorial?
It isn't. The vendors already teach hooks, skills and AGENTS.md syntax for free, and the lessons link to their docs. This course is about what you put in them: the boundaries, the failure rules and the proof that make agent-written code safe to merge.
Which coding agents does it work with?
Hooks are included for Claude Code, Codex, Cursor and OpenCode. The types, lint rules, tests and the proof check run in CI, so they hold whichever agent writes the code.
Is it React or Node?
It covers both, in TypeScript across the stack, with React and Next.js on the front end and Node on the back end.
How much time does it take?
Each lesson is a 10 to 20 minute read, plus the change you make in your own repo. You can do a lesson inside a work day.
Do I need your books first?
You don't need them. The course builds on The Conscious React and The Conscious Node, and it stands on its own.
Can my company pay?
Yes. Checkout takes your company's VAT ID, so EU businesses pay with the reverse charge, and Stripe emails a receipt you can expense. If you need an invoice with your company's details, reply to the purchase email or write to info@petarivanov.tech and I'll send one.
What is the question in the form for?
It's optional. It tells me how many of you review AI-written code and how many build AI features, and your answers decide which problems I cover first.
Join now
Get on the list before the presale
The presale opens in early 2027 at $199, and waitlist members hear first. Your answer below decides which problems I cover first.
Now
Join the waitlist
It's free. Confirm your email and the Module 1 exercise arrives first.
early 2027
The presale opens with Module 1
Waitlist members get an email that day and pay $199 for the whole presale.
After that
A new module every two weeks
Six modules and a capstone, each ending in a change to your own repo.
$199 presale price
There is nothing to buy today. You'll get my weekly newsletter, one email when the presale opens and a few notes while I build the course. You can unsubscribe in one click.