How one person ships serious software with AI agents — without the repo turning into a landfill of half-finished code and leaked secrets.
AI can write code faster than one person can review it. That is exactly the problem. Speed without a system produces impressive demos and unmaintainable repos: secrets in history, final_v3 files everywhere, commits nobody can read, and features that were never actually run. This is the system that keeps a solo builder's output serious — every change small, signed, verified, and traceable — while still moving at agent speed.
It is not a framework and not a tool. It is five habits, each written down so an agent can follow them as strictly as a human would. It's just Markdown, so it works with any coding agent and any model — Claude Code, Cursor, Cline, Continue, Aider, or a local model you run with Ollama. No vendor, no lock-in.
- Quickstart
- The five habits
- The agent loop
- Why it works
- Templates
- See it in action
- Works with any agent
- Repository layout
- Who this is for
- FAQ · Integrations · Contributing · Roadmap
- License
Two copy-paste files do most of the work — no install, no dependency:
# 1. Give your agent a commit contract it follows every time (keep it git-ignored)
curl -o COMMIT_RULES.local.md https://raw.githubusercontent.com/Hash-7777/Hash-AI-Coding-persona/main/templates/COMMIT_RULES.template.md
echo "*.local.md" >> .gitignore
# 2. Start a persistent memory your agent reads each session
mkdir -p memory && curl -o memory/MEMORY.md https://raw.githubusercontent.com/Hash-7777/Hash-AI-Coding-persona/main/templates/MEMORY.template.mdThen tell your agent, once: "Follow COMMIT_RULES.local.md for every commit, and read memory/MEMORY.md at the start of each session." This works with any agent — including a local model via Ollama (feed the two files as context). Fill in the <PROJECT> / <DEVELOPER> placeholders, and read the five habits to get the rest. A live example of both files is in examples/; per-agent recipes are in docs/integrations.md.
| # | Habit | The one line |
|---|---|---|
| 01 | Memory that persists | A file-based memory the agent reads every session, so context survives across days and chats. |
| 02 | Work-trees for parallel focus | One checkout per line of work, so a broken experiment never blocks a shipping fix. |
| 03 | Commit discipline | Explicit staging, readable outcome-focused messages, signed commits, only real files. |
| 04 | Verify before you trust | Drive the actual change end-to-end and watch it work. Tests passing is not the feature working. |
| 05 | The agent loop | Plan, build, verify, commit, record — the rhythm that ties the other four together. |
The four habits become a way of working when you run every change through the same five steps.
Each habit closes a specific failure mode of building with AI:
| Failure mode | The habit that prevents it |
|---|---|
| The agent forgets everything you agreed yesterday | Persistent memory |
| A risky experiment breaks the branch you were about to ship | Work-trees |
| A secret or a scratch file lands in git history forever | Commit discipline |
| "It's done" — but it was never actually run | Verify before you trust |
| Work drifts, no record of why a decision was made | The agent loop |
Ready-to-copy starting points live in templates/:
| Template | Use it for |
|---|---|
| COMMIT_RULES.template.md | Drop into any repo as a local, git-ignored contract for how commits happen. |
| MEMORY.template.md | The shape of a persistent memory index — one line per fact, loaded every session. |
examples/ has a working memory/ folder (a real index with user / feedback / project memories), a commit message that follows the discipline, and a before/after of the same afternoon of agent work — messy without the system, clean with it.
The whole system is Markdown an agent reads — so it's tied to no vendor and no model:
| Agent / setup | How you apply it |
|---|---|
| Claude Code | Point it at COMMIT_RULES.local.md and memory/; reference the habit docs in your prompt |
| Cursor · Cline · Continue · Aider | Paste the commit contract into the rules field; keep the memory folder in-repo |
| Local models via Ollama | Feed the two template files as context, or bake the commit rules into a Modelfile SYSTEM block |
| Any chat model | Give it the habit doc for the task and the commit contract before it writes a commit |
Because it runs on local models too, the whole workflow works offline, on private code that never leaves your machine. Recipes for each are in docs/integrations.md.
Hash-AI-Coding-persona/
├── README.md
├── LICENSE MIT
├── CONTRIBUTING.md how to propose a habit
├── ROADMAP.md what's coming next
├── docs/
│ ├── FAQ.md
│ └── integrations.md per-agent recipes (incl. Ollama)
├── assets/
│ ├── hero.svg banner
│ ├── loop.svg the agent-loop diagram
│ └── social-card.svg link-preview card
├── system/
│ ├── 01-memory.md
│ ├── 02-worktrees.md
│ ├── 03-commit-discipline.md
│ ├── 04-verification.md
│ └── 05-agent-loop.md
├── templates/
│ ├── COMMIT_RULES.template.md
│ └── MEMORY.template.md
└── examples/
├── README.md live memory folder, a real commit, before/after
└── memory/ a working memory index with sample facts
A solo developer, or a very small team, using coding agents to build real products — not toys. If you have ever force-pushed to purge a leaked secret, spent an afternoon untangling two features committed together, or shipped a "fix" that never worked, this system is the fix.
MIT — take it, adapt it, make it yours.