What The Craft is

The Craft is the art of building end-to-end applications with Claude — apps that are scalable, maintainable, and easy to keep evolving, migrating, and changing across the whole life of the project. Not a framework, not a library — a human + agent doctrine: a tight set of rules, commandments, and anti-patterns that keep the code understandable to the next session, testable, safe to change, and trustworthy — from the first commit to production with real users.

In one paragraph

Most AI-built projects don’t fall apart because the agent can’t write code — they fall apart because nobody set the rules. The Craft is those rules: you attach them to a project as docs/rules/, and from Day 0 Claude knows “how we do things here.” The result is an app with an extremely flexible structure of files and technologies — you start simple (one server, one database), and the structure is ready for growth from the outset: separated layers, Feature flag — An internal switch that turns a new feature on for some people, or off, without reworking the code. You roll a novelty out gradually and roll it back in a second — the cheapest insurance with any change., forward-only Migration (database) — A controlled change to the database layout — adding a column, a table or moving data — step by step. Like a renovation to plan: rebuilding data in a set order so nothing “collapses”., Slug — A readable, short part of a page address that describes its content in words instead of a mysterious number. Better for humans and SEO; a stable slug doesn’t break links when things change. instead of ID. You evolve, migrate, and scale without rewriting from scratch — all with respect for personal privacy and the law (GDPR — The EU’s data-protection law — how you may collect, keep and delete users’ data. It concerns every app with people’s data. Better to write in consents and retention from the start than pay fines later., consents, protecting the creator) built in from the start, not bolted on at the end.

Who it’s for

A single developer — a solo creator or a one-person shop — building and running a real application individually, with AI as the pair: not an enterprise team with dedicated ops, QA, and reviewers. It’s written to that scale — one head, one server, one deploy you can hold in your mind. “Solo” doesn’t mean “one writer”, though: you’ll routinely run several Claude sessions at once on the same repo (a fix in one, a feature in another), and that is already a multi-writer situation. So the coordination rules here (issues, short branches, push/pull discipline, “don’t ship what you didn’t mean to”) exist for parallel agent sessions — they earn their keep the moment a second session is open, long before any human teammate appears (→ 05, 06).

What you get

Code that reads like prose — matched to its surroundings, easy to review for a human and an agent.
Git history as the project’s memory — search before you write; never reinvent what already exists.
Verification instead of declaration — “it works” means proof: a Smoke test — A quick “does it even work” test right after a deploy — checks the most important paths (e.g. login). Catches disasters in 30 seconds before a user sees them. A cheap way to sleep well after a deploy., an HTTP code, numbers, a screenshot.
Safe changes — Dry-run — A “dry” run — the script shows what it WOULD do but changes nothing. You see the effects before executing; a data change happens only after deliberate confirmation. by default, a backup before every migration, production is sacred, user data is untouchable.
Flexibility and scalability — a Monolith — An app built as one whole (one deploy, one database), not a patchwork of separate services. A simple, cheap default to start — easy to grasp. You split it only when scale really demands. on a single VPS — A rented piece of a cloud server “just for you”, where you put an app “live”. Predictable cost and full control. One VPS easily carries a few small projects. as the simple default, with an explicit growth path (SQLite — The simplest database — the whole thing lives in one file, with no separate server. A great default to start: zero configuration, easy backup (you copy the file). As you grow, you migrate up. → PostgreSQL — A solid, “grown-up” database for bigger apps — runs as a separate server. The default step after SQLite, when you need many concurrent users and advanced features., VPS → Serverless — A model where you don’t manage a server — the code runs itself when someone needs it, and sleeps when not. You pay per use, it scales itself. The trap: a “cold start” — the first call can be slower.) when a metric forces it.
Legal peace of mind — terms of service, a privacy policy, and disclaimers as the creator’s armor, not an afterthought.

Why you should try building an app with The Craft

Because the difference isn’t whether the agent writes the code — it’s what your project looks like three months from now. Without rules, every agent session adds a little chaos: inconsistent style, documentation that lies, a migration with no backup, a deploy “because it’s done.” A quarter later you have an app you’re afraid to touch. The Craft reverses that trajectory: every change leaves the project cleaner, not worse.

You start fast, not cheap. One server, a simple stack, a monolith — something you can hold in your head: one deploy, one log, one backup, one Rollback — Reverting a change to the previous, working state — “Ctrl+Z” for a deployment. When a new version breaks production, a rollback restores the previous one in seconds instead of fixing in a panic.. That isn’t “primitive” — it’s cheap to maintain. And when real scale finally arrives, the structure is already waiting for it: layers are separated, keys are stable, migrations are one-way. Growth and migration stop being a rewrite and become an addition.

Human and agent play toward the same goal. Plan → iterate → review. The agent doesn’t guess — it follows a proven recipe, searches the history, reports honestly (failures included, not just wins). You stay the architect of decisions, not the proofreader of chaos. It’s a collaboration where trust is built on proof, not optimism.

Privacy and the law are handled from Day 0. GDPR, consents, retention, protecting the creator — written as policies into the project’s constitution before the first real user shows up. No late-night scrambles “because someone asked to delete their account.”

Best of all: it’s reusable. The Craft isn’t built “for one project.” You attach it as docs/rules/ to every new app, fill in the brief, and go — and each new project benefits from the lessons of the last.

You don’t even have to read the whole Decalogue first. The fastest start: install Claude Desktop / Claude Code, fill in the brief, attach The Craft as docs/rules/ — and you’re off. The agent reads the rules so you don’t have to memorize them; the doctrine just works in the background.

Try it once. Take your next idea, attach The Craft, start from Day 0, and build it like a craftsman — slow where a mistake is expensive, fast where it’s cheap. You’ll see the difference not on day one, but in month three — when the app is still a pleasure to work on. Start with the Decalogue: the whole doctrine on a single screen.