Why This Works

Under the beginner pages is a simple method that keeps compounding.

The beginner pages help you move. This page explains the habits underneath them so you can understand why the system keeps getting better over time.

Four Habits

These are the ideas the rest of the site keeps pointing back to.

If the beginner layer helps you move, these are the habits quietly turning those small sessions into something durable.

Keep teaching the agent

You do not write one perfect setup once. You keep updating the rules as you learn what helps and what annoys you.

Be specific

“Be helpful” is too vague. “Give me three short options and tell me which one you would choose” actually changes behavior.

Step back and review

The same setup that helps you move can also hide what is not working. At some point, you need to pause and review it.

Fix the recurring problem

Do not drown in a list of possible improvements. Improve the thing that keeps coming back and let the rest go.

Translation

If you hear Andy's original terms, here is the plain-English translation.

You do not need this vocabulary to begin. It is here so the deeper notes make sense when you are ready for them.

Lesson 1

Your Personal Rules For The Agent

Andy calls this a constitution. This is a short written list of how you want the agent to behave with you: how much detail you want, how you like options shown, and what it should stop doing.

Open the guide note

Lesson 2

Save Your Progress At The End

Andy calls this session close. Session close is the habit of ending with a short, readable handoff note so the next session can restart without guesswork.

Open the guide note

Lesson 3

Think In Passes For Harder Problems

Andy calls this the synthesis engine. This is how power users stop treating the agent like a vending machine. You use it for multi-pass thinking, not just instant answers.

Open the guide note

Lesson 4

Improve One Thing At A Time

Andy calls this a quality loop. This is how you get better on purpose. You define the metric before making variants, then score, pick, and learn.

Open the guide note

Lesson 5

Step Back And Review Your Setup

Andy calls this a meta-layer audit. Once your setup starts feeling comfortable, you need a different mode whose whole job is to find what is wrong with it.

Open the guide note

Map

How the five beginner days connect to the deeper guide notes.

The sprint is not separate from the method. It is a friendlier way into it.

Day 2

Publish a tiny first website

Beginners get confidence from making something public fast. A janky live site teaches more than ten perfect drafts.

Day 3

Use the agent on a real work task

The right beginner workflow is not fantasy automation. It is a real task from your actual week.

Day 4

Try a few versions and keep the winner

Real confidence comes from knowing why one version is better, not from vaguely feeling that it is.

Day 5

Write your default rules and pick your next project

By the end of the first week, the goal is not just a few artifacts. It is a simple way of working you can keep extending.

Guide Notes

Open the longer explanation only when you want more depth.

This keeps the original long-form orientation available without forcing it on someone who is still getting their first win.

Open Andy's longer guide notes This is the deeper original explanation behind the site.

Everyone uses AI. The field is full of people sharing tips, techniques, and tutorials. Karpathy explains how the models work. Dozens of guides teach you how to write better prompts. You can find thousands of CLAUDE.md templates on GitHub.

So why does this site exist?

Four things that aren't out there. Not in the prompt engineering guides. Not in the LLM explainers. Not derivable from first principles without having lived through building an AI operating methodology from scratch.


The Four Things

1. Your constitution is a live document, not a setup step

Everyone is converging on "write a CLAUDE.md" or "build a system prompt." That's the technique. The insight most people miss: the value is in the updating, not the artifact.

A system prompt you write once and leave alone starts decaying immediately. Your context changes. Your vocabulary evolves. You learn what the AI gets wrong about how you work. The frozen version drifts from reality.

The constitution is only valuable as a live document with an active update history. The update history IS the product. What has changed, when, and why — that's what makes it an accurate model of how you work, rather than a snapshot of how you thought you worked when you wrote it.

What this changes: You don't "set up your constitution." You maintain it. The habit is updating, not writing.


2. "Specific enough to be wrong" is the quality test

Most people write constitutions that don't actually constrain anything. "Be concise and helpful." "Use a professional tone." "Think step by step."

These are aspirational. They can't be violated in any way you'd notice. The AI could produce exactly what you hate most and technically comply with "be concise and helpful."

The test: is your instruction specific enough that the AI could clearly violate it?

  • "Be helpful" — not specific enough to be wrong. Fails the test.
  • "When I ask for options, give me exactly 3, in bullet points, and tell me which one you'd choose." — specific enough to be wrong. Passes.

A constitution full of instructions that pass this test is a constitution that's actually doing something.

What this changes: You evaluate your constitution not by whether it sounds good, but by whether each line could be violated in a way you'd immediately notice.


3. You cannot audit your own constitution from within it

After you've built a working constitution and are running sessions with it, you will have a blind spot: the same session running on your constitution can't reliably find where the constitution is wrong.

The AI in a normal session is optimizing to work within your stated principles. It has been told what you value. It gives you outputs consistent with that framing. If your constitution says "I value rigor," the session will confirm rigor — not question whether rigor is actually what you need right now.

This is a structural property of any system that runs on its own rules. You cannot audit yourself from inside your own methodology.

The solution is architectural: a separate session type with an explicit mandate to find where the primary system is wrong. Different context loaded. The instruction isn't "help me work" — it's "tell me where my working methodology is failing."

Most people never run this session. Their constitutions drift further from useful over time while they feel like the system is working fine.

What this changes: A quarterly session with one job — find what's wrong. This is not the same as your normal sessions. It's architecturally separate.


4. Trust resurfacing over cataloguing

The natural instinct when you see a problem with your AI workflow: add it to a list. "Things to fix eventually." The list grows. Most items sit there for months, get reviewed occasionally with good intentions, and mostly never get addressed.

The alternative: no list. If a problem matters, it will resurface. When it resurfaces, that's your signal to run a loop and fix it. If it doesn't resurface, it wasn't worth fixing.

This sounds risky. What if you miss something important? Here's what's actually happening: the things that stay on your list without resurfacing weren't blocking you. They were noise that felt signal-adjacent once. The signal is in the resurfacing — that's what tells you a problem is load-bearing.

A backlog of AI workflow improvements is a backlog of things you'll feel slightly guilty about and never actually address. Trust the system.

What this changes: When you notice a problem with your methodology, you don't add it to a list. You either fix it now (if it's surfaced) or let it go. The discipline is deciding: now or never.


What Comes Next

These four insights are the reason this site exists. The techniques in the curriculum implement them:

  • The constitution lesson teaches how to build something that passes the specificity test and that you'll actually maintain
  • Session close makes the constitution durable across sessions
  • The synthesis engine is the technique that makes your constitution most useful
  • Quality loops are the mechanism behind the resurfacing principle
  • The meta-layer audit is the architectural solution to insight 3

Start with lesson 1.