If you’ve ever spent an hour re-explaining your repo to a fresh agent after a cap, Selfdev turns that limit into a clean handoff. One agent plans. Git stores the memory. The next agent continues exactly where the last one left off.
You hit “limit reached” mid-debug. The next chat doesn’t know your stack, your files, the bug, the constraints — or the three approaches you already ruled out. So you start over. Most of “AI productivity” gets eaten by this restart tax.
Every fresh agent asks for the repo, the goal, the bug, the logs, the constraints — every single time.
Rejected fixes come back. Architecture gets re-questioned. The new agent touches files it should’ve left alone.
Your strongest model gets burned on repetitive implementation a scoped, cheaper agent could ship in half the cost.
Selfdev fixes this with one shift: stop trusting chat memory. Start using git as shared project state.
Every agent gets a clean continuation point. Tasks are split into numbered increments with acceptance criteria, the project state lives in git, and the next agent receives a concrete prompt — not a 200k-token chat transcript.
Burn premium tokens on what they’re worth: architecture, hard debugging, API design, and risky trade-offs.
Selfdev writes the next todo/ increment, applicable how/ rules, acceptance criteria and commit trace into a continuation-ready brief.
Cheaper agents implement scoped increments without guessing — they follow a tracked requirement and commit when done.
You’re the architect. Selfdev makes the routing explicit: send hard thinking to your strongest model, then ship the same work cheaper by handing scoped increments to a smaller agent.
Strong model for thinking. Cheap agent for shipping. Git for memory. The next time your agent stops, your build doesn’t.
*Provider limits, outages and account restrictions still exist. The goal is that one limit should never reset your project memory or force the next agent to rebuild context from zero.
Selfdev now ships matching agent definitions for .github/agents/, .codex/agents/, .claude/agents/ and .cursor/rules/, plus a queue-free ./plan.sh planner. The tracked GitHub agent files are know-agent, selfdev-plan-agent, selfdev-do-agent and selfdev-coach.
Knowledge analyst. Scans how/, cross-references with todo/ and source code, validates consistency, and produces a structured quality report before planning or execution.
Planning agent. Clarifies the task, reviews git history for patterns, analyses the codebase, and writes a TDD-ready todo/ increment linked only to the relevant how/ files.
End-to-end execution agent. Creates or consumes the current todo/ increment, runs ./todo.sh, implements exactly what is specified, tests, commits, pushes, and repeats until the queue is clear.
AI coding tutor and implementation coach. Guides developers through tasks, hint ladders, test reasoning, code review feedback, weak-point tracking, and spaced repetition.
Queue-free planning CLI. Run python3 plan.py "Fix upload retry" or ./plan.sh "Fix upload retry" to get the exact next todo/ file path, TDD order, and verification gates without advancing the queue.
Each one was built across multiple AI cap resets — the same workflow that ships this site shipped the apps below.
Selfdev pipeline self-reconfigured to generate learning content. TypeScript RED is the public proof case: the same repo-native workflow that coordinates agents now creates TypeScript exercise artifacts, challenges them with gates and diagnostics, keeps the review trail visible, and ships the accepted output as a static learning site.
100% Free & No Registration. 14-day car wash calendar powered by weather analysis. Scores each day 0–100 based on rain, wind, UV, humidity & temperature. Best-time window recommendation, post-wash rain outlook, and auto-detect location — all privacy-first with data staying local.
Portfolio website, 100% created by selfdev logic.
The how-to guide on Cloud Agents.
This website, developed by selfdev logic.
Copy the Selfdev package into a repo root and run ./todo.sh. No pip installs, no extras — just Python 3.8+.
Work is pre-split into numbered todo/ increments with acceptance criteria, parse warnings, and linked how/ rules.
User, Test, System, Analytics and Debug perspectives score your codebase from 0.0 to 1.0 — so you fix the worst thing first.
Copilot, Claude, ChatGPT, Gemini, Cursor — all evolve the same repo. State lives in git, not in any single chat session.
Every completed increment advances a generation after tests pass. Revert and redo prompts let you unwind a bad increment from git history.
Subclass PerspectiveAnalyzer in perspectives.py to add your own checks. Selfdev is a frame, not a cage.
Clone https://github.com/evgeny-trushin/selfdev to a temp dir, copytodo.sh,plan.sh, the Python modules,todo/,how/, and the agent folders into my project root, then run./todo.sh. Read the generated prompt, implement it, commit, and run./todo.sh --advance. Repeat until all increments are completed.
Requirements: Python 3.8+ — nothing to pip install.
| Command | Description |
|---|---|
./todo.sh | Show the current increment prompt |
./todo.sh --advance | Run the test gate, mark current done, show next |
./todo.sh --state | Print organism state & fitness |
./todo.sh --user | Documentation, UX, features |
./todo.sh --test | Coverage, missing tests |
./todo.sh --system | Complexity, coupling, architecture |
./todo.sh --analytics | Trends, patterns over time |
./todo.sh --debug | TODOs, FIXMEs, bugs |
./todo.sh --all | Run all five perspectives |
./todo.sh --revert=0001 | Generate a git-history revert prompt for one increment |
./todo.sh --revert_from=0020 | Generate a reverse-order prompt for a range of increments |
./todo.sh --redo=0001 | Generate a revert-and-reimplement prompt |
./todo.sh --selfdev | Analyze selfdev itself |
./todo.sh --root DIR | Analyze a different directory |
./plan.sh | Generate a queue-free prompt naming the next todo file to create |
./plan.sh "Fix upload retry" | Plan a free-form requirement without selecting or advancing the queue |
python3 plan.py "Fix upload retry" | Same planner behavior through the Python entry point |
./plan.sh --all-principles | Print the full how/ convention guide |
Work is pre-split into numbered increments stored in todo/. Each file contains a description, acceptance criteria, and links to applicable how/ files. The current loop runs through ./todo.sh:
_todo_ increment file.how/ and inject their full text into the prompt.how/ rules + commit message../todo.sh --advance runs the test gate, renames _todo_ → _done_, advances the generation, and shows the next increment../plan.sh is the planning companion for the loop. It intentionally does not read, select, summarize, or advance the current increment queue. With no arguments it names the next todo file using model/summary tokens; with text such as ./plan.sh "Fix upload retry" it names the next slugged todo/ file and outputs TDD order plus automated, visual, and runtime-evidence verification gates.
Selfdev enables stateless collaboration across cloud environments: one agent commits and pushes, the next agent clones and continues immediately without chat history transfer.
| Perspective | Analyzes |
|---|---|
| User | README quality, docs, feature completeness |
| Test | Test coverage ratio, missing test files |
| System | McCabe complexity, file size, coupling |
| Analytics | Commit trends, fitness history, patterns |
| Debug | TODOs, FIXMEs, syntax errors, uncommitted changes |