The full course$199, all 17 modules, lifetime
Get it for $199Your coding agent starts every session from zero and guesses the rest. Paste one line into the agent you already use, and about fifteen minutes later your own repository has a memory it reads before it writes: the decisions behind your code, written down from the code itself. You leave with the files on disk and a card that scores what your agent knew before and after. Free, open source, and no account needed to run it.
Step 1 of 3. Do it on your own repository
Clone https://github.com/NirDiamant/Agentic_Engineering into a temp folder, read its RUN.md, and follow it on this repository.
What it did on other people's repositories
Their own repos, their own agents, posted by them in the box below.
We ran it on repositories you already depend on
| repo | before | after | docs its own code disproves |
|---|---|---|---|
| fastapi | 2 of 5 | 5 of 5 | 2 |
| flask | 3 of 5 | 5 of 5 | 6 |
| django | 3 of 5 | 4 of 5 | 1 |
| express | 2 of 5 | 4 of 5 | 4 |
| requests | 2 of 5 | 4 of 5 | 0 |
| langchain | 5 of 5 | 4 of 5 | 5 |
Our own runs, on public code, on 2026-09-21. Clone any of them, paste the same line, and check the number yourself. The last column counts statements in that project's own documentation that its own code disproves.
Or watch it happen first
Loading video…
Four minutes, on a repository that is not yours.
Step 2 of 3. Answer its five questions, approve, and read your card
AGENT MEMORY CHECK: seo-autopilot
Before the docs layer: 3 of 5 questions right
After: 5 of 5
It was guessing about: which tools are installed vs only planned; the conventions the linter actually enforces; that packages/db is wired to nothing
Contradictions found in your existing docs: 5
Written: CLAUDE.md + 4 docs, 4 unconfirmed
Still advisory: nothing enforces these rules. That takes hooks, tests, CI.A real run on a real repo, not a mock-up.
The last line is the one this course is about: the rules are written down, and nothing yet makes the agent follow them.
Step 3 of 3. Paste your card here
The run already gave you the docs layer and the card. Paste the card here and your score is saved, with the lab marked done.
Seven lines, exactly as your run printed them.
The full course
17 modules, each one a video lesson and a hands-on lab on your own project, with acceptance criteria you tick off. You finish with a real product of yours, live on a real domain.
“I went through the module and I like that you explicitly separate advisory rules from rules that become executable through hooks, tests or CI.”
You keep the layer you just built. The course adds the hooks, tests and gates around it.
30 days, no questions, the refund path is automated. One payment, yours for good.
Your company can pay for this. The email to send your manager, and an invoice with the company name and VAT number.
Your coding agent starts every session from zero, and it guesses the rest. To show you, I asked mine five questions about my own project, before it read any code. Here is one answer. It named the billing tool this project uses, and it said it was sure. That tool is not installed. I looked in the package files, in the lockfile, and in every source file, and it is nowhere.
The same answer gave the scheduled jobs to a second tool, and said that tool was better than the simple option. The simple option is the one that is installed.
Both names are real. They are in the project's plan, in a part that was never built. How do you know what your agent believes, before it writes? So the problem was not that it read too little. It read the whole plan, and it reported the plan as if it were the thing that was actually built.
And here is the part that should worry you. It also reported a mismatch. It told me this project uses one keyword service, but the code had already switched to another one. It used the old file to correct the file that was right.
Five questions, before it read any code. Three right, two wrong. And its confidence labels told you nothing, because one guess turned out right, and the answer it was sure about was the wrong one.
I'm Nir. More than forty thousand people read my newsletter about building with AI, and I built a fix for this problem. It is called Agentic Engineering. It is free, and it is open source. It is one line that you paste to your coding agent. In about fifteen minutes, it reads your real code, and it writes down the decisions behind that code, the things your agent can never see in the code itself. From then on, your agent reads those decisions before it writes anything, in every session. I am giving it to you as a gift. Run it on your own project, and you will feel how much better it is to work with an AI that actually knows your project. And it is a small piece of something bigger, which you will see at the end.
So I pasted that line to the same agent, in the same session that gave the wrong answer. Before it touches anything, it prints four promises, and the third one is the one I care about. It stops once and asks for my approval. Before that, the only new file on disk is the scorecard with those five answers.
That was the free module. The rest of the method is the course.
All 17 modules, a lab on your own project in each, lifetime access. 30 days, no questions, the refund path is automated.
Get the full course for $199Then it reads the project for two and a half minutes, and checks which file imports which. This is the database package the readme talks about. Seven lines, one constant, and nothing imports it.
Then it asks me five things my code cannot answer. One of them is the scheduler it got wrong at the start. Now it asks, instead of guessing. Nobody was there to answer, so it used what the code shows, and marked the gap as unconfirmed.
It wrote four hundred and fifteen new lines, in six new files, and it did not change one line of mine.
Then the same five questions, to a new agent session that sees only the files this run wrote. This time it names something that is actually installed, and it can point to the line where that decision is made. And where the reason for a change was never written down, it says so, instead of inventing a reason.
Three right before, five right after, and five claims in my own documents that my own code proves wrong. It started at three and not at one, because this project already had a readme and a plan. And that is what my agent knows now, on every task, in every session, without me explaining it again.
Here is how you do it on your own project. The line is on this page. It is the same line in the repo's readme, under the words Run it. One line, and that is the whole setup.
You paste it to the coding agent you already use, in the project you already have open. Nothing to install, no account, and it never asks you for an API key.
Halfway through, it stops and asks you five questions about your own project. Simple questions, one sentence each. Answer them, and the file it writes is better. Nobody was there to answer for mine. Three of the five were marked as unconfirmed, and it kept going. Be there for yours.
What you get is a file at the root of your repo, that your agent reads before it writes anything, in every session after this one. Your score goes into a second file next to it, with the card at the end. The longer notes it wrote from your code go into a folder, and the root file points to them. When it is done, paste your card into the box on this page. That saves your score, and it marks this module as complete.
The last line of that card is the honest one. Your agent will try to follow these files, and nothing forces it to. A rule that must hold every single time belongs in a hook, a test, or a CI gate, and none of that is included here.
A hook can stop a bad write before it happens, a test can fail the moment your agent breaks a rule, and a gate can refuse the merge. Those three are code, not documents, so they hold by themselves.
Writing the rules down is the half you just did. It is also the first step of a much bigger method, and the rest of that method is the course. Today, anyone can build a prototype with AI. Shipping a real product is hard. And trusting the code the AI writes is hard too. The course solves both. It is called Prompt to Production. Seventeen modules, and each one is a video lesson and a hands-on lab, with a checklist you tick off, so you know it worked. In the lessons, we build one real project together, step by step, until it is in production. In the labs, you do the same steps on your own project. The hooks module turns the rules you just wrote into checks that run on every action. The testing module puts tests and review around every change. The deploy module puts your project on a real domain. By the last module, it is a real product of yours, live, that strangers can sign up for.
You can try the course without risk: thirty days, no questions asked, and the refund is automatic. The button is on this page, above this lesson.
Your agent can ignore one of those halves. It cannot ignore the other. See you inside.