tdd-migrate
TDD workflow for migrations - orchestrate agents, zero main context growth
Install / Use
npx skills add parcadei/Continuous-Claude-v3 --skill tdd-migrateInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
AutomationSupported Platforms
Our assessment of tdd-migrate
tdd-migrate scores 83/100 on our quality scale, 2187th of 2,780 Automation skills we index.
Its SKILL.md is 5.5 KB long, well organised into 22 sections with 14 code examples: a solid amount of guidance for an agent.
With 3,943 GitHub stars, it is one of the more widely adopted skills in the catalogue.
Maintenance, license and trust
- The repository was last updated about 10 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.
- Our last check on 2026-11-06 found the source still online.
- It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
- Its trust signals score 94/100, with 1 caution from licensing, adoption, age or documentation. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-10-01. Automated pattern scan on 2026-10-01. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
tdd-migrate compared with similar skills
All 4 of these similar skills score higher than tdd-migrate; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| tdd-migrate (this skill)by parcadei | 83 | 3.9k | 10mo ago | SKILL.md |
| Agent-Reachby Panniantong | 100 | 112.3k | 9d ago | CLAUDE.md |
| rufloby ruvnet | 100 | 81.9k | today | CLAUDE.md |
| headroomby headroomlabs-ai | 100 | 79.8k | today | CLAUDE.md |
| Claude-Code-Game-Studiosby Donchitos | 100 | 39.7k | 7d ago | CLAUDE.md |
Frequently asked questions
- How do I install tdd-migrate?
- Run
npx skills add parcadei/Continuous-Claude-v3 --skill tdd-migrate. The install tabs above show the steps for each supported agent. - Which AI agents does tdd-migrate work with?
- It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is tdd-migrate safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 94/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is tdd-migrate still maintained?
- The repository was last updated about 10 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.
Skill content
View source on GitHubname: tdd-migrate description: TDD workflow for migrations - orchestrate agents, zero main context growth allowed-tools: [Task, TodoWrite, Write, Read, Bash]
TDD Migrate
Orchestrate TDD migrations with agents doing all work. Main context stays clean.
When to Use
- "Port X from Python to TypeScript"
- "Create N adapters following existing pattern"
- "Migrate module to new architecture"
- "TDD implementation of multiple similar items"
Parameters
/tdd-migrate <source_path> <target_path> --pattern <reference> --items "item1,item2,item3"
source_path: Path to analyze (existing code)target_path: Where to create new codepattern: Reference file/pattern to followitems: Comma-separated list of things to create
Workflow
Phase 0: YAML TODO List
│
▼
Phase 1: TLDR Analysis ─────────────────┐
│ │
▼ │ Parallel scouts
Phase 2: Write Failing Tests ───────────┤ per item
│ │
▼ │
Phase 3: Implement (minimal) ───────────┤
│ │
▼ │
Phase 4: Build + Pass Tests ────────────┘
│
▼
Phase 5: QLTY Check ────────────────────┐
│ │ Parallel
Phase 6: Review Agent Validates ────────┘
│
▼
Phase 7: TLDR Diff (new vs reference)
│
▼
Phase 8: Fix Issues (if any)
│
▼
Complete
Key Principles
-
Main context = orchestration only
- Never read files directly (use scout)
- Never implement directly (use kraken/spark)
- Never run tests directly (use validator)
- Only pipe context and coordinate
-
Agents do ALL work | Task | Agent | |------|-------| | Explore/analyze | scout | | Write tests + implement | kraken | | Quick fixes | spark | | Run tests/validate | validator | | Code review | critic |
-
Parallel where independent
- All items can be implemented in parallel if independent
- Review + QLTY run in parallel
- TLDR analysis runs in parallel with planning
-
Review after each major step
- After implementation: critic reviews
- After fixes: validator re-validates
Instructions
Step 0: Create YAML TODO
Write a YAML plan file to thoughts/shared/plans/<name>-tdd.yaml:
---
title: <Migration Name>
date: <today>
type: implementation-plan
approach: TDD (test → build → pass → review)
items:
- name: item1
file: <target_path>/item1.ts
test: <target_path>/__tests__/item1.test.ts
deps: []
- name: item2
# ...
reference: <pattern_file>
workflow:
per_item:
1: Write failing test
2: Implement minimal
3: Build
4: Pass test
5: QLTY check
6: Review
final:
7: Integration test
8: TLDR diff
Step 1: Launch Scout Agents (parallel)
Task (scout): Analyze <source_path> with TLDR
Task (scout): Analyze <pattern> to understand structure
Task (scout): Read migration handoff if exists
Step 2: Launch Kraken Agents (parallel per item)
For each item, launch ONE kraken that does full TDD:
Task (kraken): Implement <item> using TDD workflow
1. Read pattern file
2. Write failing test
3. Implement
4. Run: bun test <test_file>
5. Run: qlty check <impl_file>
Step 3: Review + Validate (parallel)
Task (critic): Review all new files against pattern
Task (validator): Run full test suite
Task (validator): QLTY check all files
Step 4: Fix Issues
If critic/validator found issues:
Task (spark): Fix <specific issue>
Task (validator): Re-validate
Step 5: TLDR Diff
Task (validator): TLDR diff new files vs reference
- tldr structure <new_file> --lang <lang>
- tldr structure <reference> --lang <lang>
- Compare patterns
Step 6: Update Continuity
Update ledger with completed work.
Example: Rigg Adapters
/tdd-migrate /Users/cosimo/Documents/rigg/src/sdk/providers \
/Users/cosimo/Documents/rigg/src/sdk/providers \
--pattern lmstudio.ts \
--items "xai,cerebras,togetherai,deepinfra,perplexity"
Resulted in:
- 5 parallel kraken agents
- 39 tests passing
- All adapters working
- ~15 minutes total
Anti-Patterns (AVOID)
| Bad | Good | |-----|------| | Read files in main context | Launch scout agent | | Write code in main context | Launch kraken/spark agent | | Run tests in main context | Launch validator agent | | Skip review | Always launch critic | | Sequential items | Parallel krakens | | Fix in main context | Launch spark |
Agent Prompts
Scout (analysis)
Explore <path> to understand:
1. Structure/patterns
2. Interfaces/types
3. Dependencies
Return actionable summary for implementation.
Kraken (TDD)
Implement <item> using TDD:
1. Read <pattern> for structure
2. Write failing test to <test_path>
3. Implement minimal to <impl_path>
4. Run: <test_command>
5. Run: qlty check <impl_path>
Report: status, issues, files created.
Critic (review)
Review <files> against <pattern>:
1. Pattern compliance
2. Type safety
3. Missing registrations
4. Security issues
DO NOT edit. Report issues only.
Spark (fix)
Fix <specific issue>:
1. Read <file>
2. Make minimal edit
3. Verify fix
Validator (test)
Validate <files>:
1. Run <test_command>
2. Run qlty check
3. Report pass/fail/issues
Success Criteria
- [ ] All tests pass
- [ ] QLTY reports no issues
- [ ] Critic found no critical issues
- [ ] TLDR diff shows pattern compliance
- [ ] All items registered/exported properly
Related Skills
Agent-Reach
112.3kGive your AI agent eyes to see the entire internet. Read & search Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu — one CLI, zero API fees.
ruflo
81.9k🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
headroom
79.8kCompress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.
Claude-Code-Game-Studios
39.7kTurn Claude Code into a full game dev studio — 49 AI agents, 72 workflow skills, and a complete coordination system mirroring real studio hierarchy.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
