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 ships with three specialized VS Code agents in .github/agents/. Each owns a clear part of the lifecycle so the strong model isn’t the one writing boilerplate.
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 creates a TDD-ready execution plan as a new todo/ increment linked to relevant how/ files.
End-to-end execution agent. Creates or consumes the current todo/ increment, runs ./selfdev/develop.sh, implements exactly what is specified, tests, commits, pushes, and repeats until the queue is clear.
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/ folder into any repo and run. No pip installs, no extras — just Python 3.8+.
Work is pre-split into numbered todo/ increments with acceptance criteria. No more “where were we?” after a cap.
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. Fitness history is persisted so you can prove progress, not just feel it.
Subclass PerspectiveAnalyzer to add your own checks. Selfdev is a frame, not a cage.
Clone https://github.com/evgeny-trushin/selfdev to a temp dir, copy itsselfdev/,todo/, andhow/folders into my project root, then run./selfdev/develop.sh. Read the generated prompt, implement it, commit, and run./selfdev/develop.shagain. Repeat until all increments are completed.
Requirements: Python 3.8+ — nothing to pip install.
| Command | Description |
|---|---|
./selfdev/develop.sh | Show current increment (default) |
./selfdev/develop.sh --advance | Mark current done, show next |
./selfdev/develop.sh --state | Print organism state & fitness |
./selfdev/develop.sh --user | Documentation, UX, features |
./selfdev/develop.sh --test | Coverage, missing tests |
./selfdev/develop.sh --system | Complexity, coupling, architecture |
./selfdev/develop.sh --analytics | Trends, patterns over time |
./selfdev/develop.sh --debug | TODOs, FIXMEs, bugs |
./selfdev/develop.sh --all | Run all five perspectives |
./selfdev/develop.sh --selfdev | Analyze selfdev itself |
./selfdev/develop.sh --root DIR | Analyze a different directory |
Work is pre-split into numbered increments stored in todo/. Each file contains a description, acceptance criteria, and links to applicable how/ files. Each run of ./selfdev/develop.sh:
_todo_ increment file.how/ and inject their full text into the prompt.how/ rules + commit message._todo_ → _done_, advances the generation, and shows the next increment.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 |