[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6K5TSVWXGRFMQTSM8VFSRDS":3,"skill-same:01M6K5TSVWXGRFMQTSM8VFSRDS":75},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":32,"linkOnly":33,"markdownContent":34,"markdownBody":35,"frontMatter":36,"refName":38,"commitSha":39,"skillDirectory":40,"forksCount":41,"repositoryHtmlUrl":42,"repositoryHomepageUrl":43,"ownerHtmlUrl":44,"ownerBlogUrl":45,"ownerDescription":46,"updatedAt":47,"install":48,"resources":60},"01M6K5TSVWXGRFMQTSM8VFSRDS","tdd",null,"Invoke test-driven development as an explicit one-at-a-time micro-cycle — one test, one piece of functionality, refactor, then repeat for the next behavior","laurac8r\u002Fclaude-damn","laurac8r","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F23003243?v=4","01M6K5HCAJJR4Q5BCBRRZF8E5D","Laura Kaminskiy","01M6K5HCEQRFFJFK32A0VR7AS3",3,"MIT","https:\u002F\u002Fgithub.com\u002Flaurac8r\u002Fclaude-damn\u002Fblob\u002Fmain\u002Fskills\u002Ftdd\u002FSKILL.md",[],[5,19,20,21,22,23,24,25,26,27,28,29,30,31],"test","development","micro","refactor","behavior","cycle","next","time","as","driven","true","at","for","2026-11-10 10:12:30",false,"---\nname: tdd\ndescription:\n   Invoke test-driven development as an explicit one-at-a-time micro-cycle — one\n   test, one piece of functionality, refactor, then repeat for the next behavior\nuser-invocable: true\n---\n\n# \u002Ftdd — One-at-a-Time TDD Micro-Cycle\n\n\u002Ftest-driven-development\n\nThe skill above is the core RED→GREEN discipline (watch every test fail before\nwriting code; **no production code without a failing test first**). `\u002Ftdd` adds\none thing on top of it: the **cadence**.\n\nTDD is **not** \"write the tests, then write the code.\" It is a tight loop run\n**one behavior at a time**:\n\n```\none test → watch it FAIL → minimal code → watch it PASS → refactor → repeat\n```\n\n## The Micro-Cycle\n\nFor a task with N behaviors you run the loop **N times — not once**:\n\n1. Write **one** failing test for the **next single** behavior. Nothing more.\n2. Run it. Watch it fail for the right reason (RED).\n3. Write the **minimal** code to make that **one** test pass — nothing the test\n   didn't ask for.\n4. Run it. Watch it pass (GREEN). Confirm the rest of the suite is still green.\n5. Refactor while green — remove duplication, improve names. No new behavior.\n6. **Go back to step 1** for the next behavior.\n\nOne test in flight at a time. One behavior implemented per cycle. The suite is\ngreen at the end of **every** cycle — not just at the end of the task.\n\n## The Anti-Pattern This Exists To Stop\n\nWriting **all** the tests up front, then implementing **everything** in one\npass. This is the single most common way \"I used TDD\" becomes false: it is batch\ndevelopment with the tests merely written first. You forfeit the per-behavior\nRED signal (you never watch _this_ behavior's test fail in isolation), the\nminimal-code check, and the incremental design feedback that each cycle gives\nyou.\n\nIf your test file has N tests for N behaviors and there is still no\nimplementation, you are batching — stop and collapse back to one test.\n\n## Common Rationalizations\n\n| Excuse                                                                                                                                          | Reality                                                                                                                                                                                                                                                                                                                                                                                                                                                       |\n| ----------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| \"Requirements are small \u002F clear \u002F independent — all-tests-first then one-pass impl is _equivalent_ to cycling, just faster\"                     | Equivalent output ≠ equivalent process. Batching forfeits the per-behavior RED and the minimal-code discipline. \"Just faster\" is the justification every batching agent reaches for — run the loop.                                                                                                                                                                                                                                                           |\n| \"The solution spans all requirements at once (one regex \u002F one function) — there's no seam to implement one behavior and leave the rest failing\" | There is a seam: implement behavior 1, let behaviors 2..N stay red. A general solution that passes everything at once was written without any of behaviors 2..N driving its design. **Arrive** at the general form one passing test at a time; don't start there.                                                                                                                                                                                             |\n| \"The combined \u002F compound case forces a general solution anyway, so writing the whole parser now is just minimal code\"                           | The minimal code for **one** combined case (e.g. `1h30m`) is not the whole parser. **If** you reach for the general solution at the first compound requirement, the later cases (more units, each invalid input) pass on first write — they never go RED, and you've batched the implementation behind them. That is the batch-leak, one requirement later. Even when the general form is where you'll land, get there by letting each _later_ test drive it. |\n| \"Strict cycling means hobbling the implementation to watch 'manufactured' red states — ceremony without safety\"                                 | The red state is not manufactured; it is the proof that each test _can_ fail and tests exactly its own behavior. Skipping it is precisely the failure `\u002Ftest-driven-development`'s Iron Law names.                                                                                                                                                                                                                                                            |\n| \"Mental tracing \u002F a dry-run substitutes for running the tests each cycle\"                                                                       | It does not. \"I traced it in my head\" is the exact thing TDD replaces with evidence. Run the test, each cycle.                                                                                                                                                                                                                                                                                                                                                |\n| \"Per-behavior red→green only matters when requirements interact or the design is unclear\"                                                       | You don't know which behavior will surprise you until it does — that's _why_ you cycle. Reserving the discipline for \"hard\" cases means never running it, because everything looks easy up front.                                                                                                                                                                                                                                                             |\n| \"The lead said it's trivial — move fast\"                                                                                                        | Move fast by cycling fast, not by collapsing N cycles into one. The micro-cycle on a small task costs minutes; debugging a one-pass implementation that's subtly wrong costs more.                                                                                                                                                                                                                                                                            |\n| \"Refactor wasn't needed — it came out clean on the first pass\"                                                                                  | Maybe — but that's a judgment made while skipping the step. Pause at green and look. Skipping refactor silently is how duplication accretes.                                                                                                                                                                                                                                                                                                                  |\n\n## Red Flags — STOP\n\n- Writing a second test before the first one is green.\n- A test file with N tests for N behaviors and no implementation yet.\n- An implementation that satisfies multiple behaviors you never wrote separate\n  failing tests for.\n- \"I'll write all the tests first, then implement\" — that's batch development,\n  not the micro-cycle.\n- Reaching for the fully-general solution before the specific tests forced it —\n  especially writing the general implementation at the **first compound \u002F\n  combined** requirement, so the remaining cases (more units, invalid inputs)\n  pass with no RED of their own. Each later behavior still gets its own failing\n  test first; implement only what _this_ test demands and let the next test\n  force the generalization.\n\nAll of these mean: collapse back to **one** failing test and resume the loop.\n\n---\n\nThis skill layers cadence on top of `\u002Ftest-driven-development`; it does not\nreplace it. Invoke that skill for the RED→GREEN rules themselves.\n","# \u002Ftdd — One-at-a-Time TDD Micro-Cycle\n\n\u002Ftest-driven-development\n\nThe skill above is the core RED→GREEN discipline (watch every test fail before\nwriting code; **no production code without a failing test first**). `\u002Ftdd` adds\none thing on top of it: the **cadence**.\n\nTDD is **not** \"write the tests, then write the code.\" It is a tight loop run\n**one behavior at a time**:\n\n```\none test → watch it FAIL → minimal code → watch it PASS → refactor → repeat\n```\n\n## The Micro-Cycle\n\nFor a task with N behaviors you run the loop **N times — not once**:\n\n1. Write **one** failing test for the **next single** behavior. Nothing more.\n2. Run it. Watch it fail for the right reason (RED).\n3. Write the **minimal** code to make that **one** test pass — nothing the test\n   didn't ask for.\n4. Run it. Watch it pass (GREEN). Confirm the rest of the suite is still green.\n5. Refactor while green — remove duplication, improve names. No new behavior.\n6. **Go back to step 1** for the next behavior.\n\nOne test in flight at a time. One behavior implemented per cycle. The suite is\ngreen at the end of **every** cycle — not just at the end of the task.\n\n## The Anti-Pattern This Exists To Stop\n\nWriting **all** the tests up front, then implementing **everything** in one\npass. This is the single most common way \"I used TDD\" becomes false: it is batch\ndevelopment with the tests merely written first. You forfeit the per-behavior\nRED signal (you never watch _this_ behavior's test fail in isolation), the\nminimal-code check, and the incremental design feedback that each cycle gives\nyou.\n\nIf your test file has N tests for N behaviors and there is still no\nimplementation, you are batching — stop and collapse back to one test.\n\n## Common Rationalizations\n\n| Excuse                                                                                                                                          | Reality                                                                                                                                                                                                                                                                                                                                                                                                                                                       |\n| ----------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| \"Requirements are small \u002F clear \u002F independent — all-tests-first then one-pass impl is _equivalent_ to cycling, just faster\"                     | Equivalent output ≠ equivalent process. Batching forfeits the per-behavior RED and the minimal-code discipline. \"Just faster\" is the justification every batching agent reaches for — run the loop.                                                                                                                                                                                                                                                           |\n| \"The solution spans all requirements at once (one regex \u002F one function) — there's no seam to implement one behavior and leave the rest failing\" | There is a seam: implement behavior 1, let behaviors 2..N stay red. A general solution that passes everything at once was written without any of behaviors 2..N driving its design. **Arrive** at the general form one passing test at a time; don't start there.                                                                                                                                                                                             |\n| \"The combined \u002F compound case forces a general solution anyway, so writing the whole parser now is just minimal code\"                           | The minimal code for **one** combined case (e.g. `1h30m`) is not the whole parser. **If** you reach for the general solution at the first compound requirement, the later cases (more units, each invalid input) pass on first write — they never go RED, and you've batched the implementation behind them. That is the batch-leak, one requirement later. Even when the general form is where you'll land, get there by letting each _later_ test drive it. |\n| \"Strict cycling means hobbling the implementation to watch 'manufactured' red states — ceremony without safety\"                                 | The red state is not manufactured; it is the proof that each test _can_ fail and tests exactly its own behavior. Skipping it is precisely the failure `\u002Ftest-driven-development`'s Iron Law names.                                                                                                                                                                                                                                                            |\n| \"Mental tracing \u002F a dry-run substitutes for running the tests each cycle\"                                                                       | It does not. \"I traced it in my head\" is the exact thing TDD replaces with evidence. Run the test, each cycle.                                                                                                                                                                                                                                                                                                                                                |\n| \"Per-behavior red→green only matters when requirements interact or the design is unclear\"                                                       | You don't know which behavior will surprise you until it does — that's _why_ you cycle. Reserving the discipline for \"hard\" cases means never running it, because everything looks easy up front.                                                                                                                                                                                                                                                             |\n| \"The lead said it's trivial — move fast\"                                                                                                        | Move fast by cycling fast, not by collapsing N cycles into one. The micro-cycle on a small task costs minutes; debugging a one-pass implementation that's subtly wrong costs more.                                                                                                                                                                                                                                                                            |\n| \"Refactor wasn't needed — it came out clean on the first pass\"                                                                                  | Maybe — but that's a judgment made while skipping the step. Pause at green and look. Skipping refactor silently is how duplication accretes.                                                                                                                                                                                                                                                                                                                  |\n\n## Red Flags — STOP\n\n- Writing a second test before the first one is green.\n- A test file with N tests for N behaviors and no implementation yet.\n- An implementation that satisfies multiple behaviors you never wrote separate\n  failing tests for.\n- \"I'll write all the tests first, then implement\" — that's batch development,\n  not the micro-cycle.\n- Reaching for the fully-general solution before the specific tests forced it —\n  especially writing the general implementation at the **first compound \u002F\n  combined** requirement, so the remaining cases (more units, invalid inputs)\n  pass with no RED of their own. Each later behavior still gets its own failing\n  test first; implement only what _this_ test demands and let the next test\n  force the generalization.\n\nAll of these mean: collapse back to **one** failing test and resume the loop.\n\n---\n\nThis skill layers cadence on top of `\u002Ftest-driven-development`; it does not\nreplace it. Invoke that skill for the RED→GREEN rules themselves.\n",{"name":5,"description":7,"user-invocable":37},true,"main","9635fb649979617cf684ea860dcaeb4eb272aa7d","skills\u002Ftdd",1,"https:\u002F\u002Fgithub.com\u002Flaurac8r\u002Fclaude-damn","https:\u002F\u002Flaurac8r.github.io\u002Fclaude-damn\u002F","https:\u002F\u002Fgithub.com\u002Flaurac8r","https:\u002F\u002Fwww.webcatgirl.com\u002F","SWE | Python, Java, Typescript, Cloud, AI, ML | Open-source, large-language model, and decision model enthusiast","2026-09-10 01:18:30",{"source":8,"skillName":5,"commands":49,"prompt":59,"zipAvailable":37},[50,53,56],{"tool":51,"command":52},"npx","npx skills add laurac8r\u002Fclaude-damn --skill tdd",{"tool":54,"command":55},"bunx","bunx skills add laurac8r\u002Fclaude-damn --skill tdd",{"tool":57,"command":58},"pnpm","pnpm dlx skills add laurac8r\u002Fclaude-damn --skill tdd","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Flaurac8r\u002Fclaude-damn\u002Fblob\u002Fmain\u002Fskills\u002Ftdd\u002FSKILL.md",[61,67,71],{"path":62,"resourceType":63,"resourceTypeDesc":64,"sizeBytes":65,"sourceHtmlUrl":66},"evals\u002Fbenchmark.json","REFERENCE","参考文档",2471,"https:\u002F\u002Fgithub.com\u002Flaurac8r\u002Fclaude-damn\u002Fblob\u002Fmain\u002Fskills\u002Ftdd\u002Fevals\u002Fbenchmark.json",{"path":68,"resourceType":63,"resourceTypeDesc":64,"sizeBytes":69,"sourceHtmlUrl":70},"evals\u002Fbenchmark.md",3190,"https:\u002F\u002Fgithub.com\u002Flaurac8r\u002Fclaude-damn\u002Fblob\u002Fmain\u002Fskills\u002Ftdd\u002Fevals\u002Fbenchmark.md",{"path":72,"resourceType":63,"resourceTypeDesc":64,"sizeBytes":73,"sourceHtmlUrl":74},"evals\u002Frationalizations.md",4854,"https:\u002F\u002Fgithub.com\u002Flaurac8r\u002Fclaude-damn\u002Fblob\u002Fmain\u002Fskills\u002Ftdd\u002Fevals\u002Frationalizations.md",[76,114,136,155,171,194],{"skillNo":77,"name":78,"nameZh":6,"description":79,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":80,"categories":81,"keywords":93,"publishedAt":32},"01M6K5V5PPEYZGPW80S9QAF7WZ","visual-aid","Use when the user asks for a quick visual aid, visual explainer, concept card, one-pager, poster, cheat sheet, infographic, visual summary, summary card, or mini explainer page — especially from input like a block of text, attached images, an attached song (lyrics\u002Faudio), a web link, a CSV\u002Fdataset, a math formula, a code snippet to walk through, a tutorial's steps, a timeline, or an A-vs-B comparison. Triggers include \"make me a quick visual aid\", \"turn this into a one-pager \u002F cheat sheet \u002F explainer\", \"summarize this visually\", \"give me a visual of\", \"explain this on a single page\", \"make a concept card for\", \"whip up a page about\", \"build a mini page that shows\", \"something I can paste into a doc explaining X\", or any request to render a topic\u002Ftext\u002Flink\u002Fimage-set\u002Fsong\u002Fdata into a standalone page. Prefer this skill over frontend-design when the ask is an explanatory single-file page (not a production UI), over playground when the output is static information display (not an interactive configurator), and over a Markdown\u002Fcode answer when the user explicitly wants a *page* (HTML). Produces a single self-contained HTML file that opens on double-click without a server.","https:\u002F\u002Fgithub.com\u002Flaurac8r\u002Fclaude-damn\u002Fblob\u002Fmain\u002Fskills\u002Fvisual-aid\u002FSKILL.md",[82,87,90],{"categoryNo":83,"categoryName":84,"taxonomyType":85,"taxonomyTypeDesc":86},"01JBSEEDCAT000000000000009","前端开发","SCENARIO","使用场景",{"categoryNo":88,"categoryName":89,"taxonomyType":85,"taxonomyTypeDesc":86},"01JBSEEDCAT000000000000015","视觉设计",{"categoryNo":91,"categoryName":92,"taxonomyType":85,"taxonomyTypeDesc":86},"01JBSEEDCAT000000000000016","图像与多媒体",[94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113],"visual aid","visual","standalone","frontend-design","static","information","SET","render","card","click","quick","infographic","formula","images","up","visual explainer","Audio","design","frontend","song",{"skillNo":115,"name":116,"nameZh":6,"description":117,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":118,"categories":119,"keywords":120,"publishedAt":32},"01M6K5TZZ34SBMQMN2EX11XMYS","tesseract","Use when you've been poking at the same file, concept, or problem across many sessions and want to step outside time to see its whole arc — or when you want to leave a note for next-session-you. Triggers: 'I've been going in circles on X', 'what have I learned about X', 'what did past-me say about X', 'I keep rediscovering this'.","https:\u002F\u002Fgithub.com\u002Flaurac8r\u002Fclaude-damn\u002Fblob\u002Fmain\u002Fskills\u002Ftesseract\u002FSKILL.md",[],[116,121,122,123,124,125,95,26,126,127,128,129,130,131,31,132,29,133,134,135],"say","learned","triggers","anchor","across","me","use","session","file","sessions","problem","concept","morse","you","keep",{"skillNo":137,"name":138,"nameZh":6,"description":139,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":140,"categories":141,"keywords":142,"publishedAt":32},"01M6K5TP1KX237V9FDZ8PMNXH5","tdd-cat","TDD workflow with subagent-driven-development — \u002Ftdd composed with \u002Fcat, plus the A\u002FB TDD execution-mode axis (split-phase vs micro-cycle) asked as a third question in \u002Fcat's combined pre-dispatch question","https:\u002F\u002Fgithub.com\u002Flaurac8r\u002Fclaude-damn\u002Fblob\u002Fmain\u002Fskills\u002Ftdd-cat\u002FSKILL.md",[],[143,144,5,145,146,29,147,148,27,24,149,150,151,152,153,21,20,154,28],"cat","tdd cat","task","mode","split","with","dispatch","question","subagent","tdd workflow","execution","workflow",{"skillNo":156,"name":157,"nameZh":6,"description":158,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":159,"categories":160,"keywords":161,"publishedAt":32},"01M6K5TGDERXT82MS7SB3ZGA3V","task-list","TaskCreate \u002F TaskUpdate \u002F render the current TaskList in response to `\u002Ftask-list` (with or without flags). The skill body executes immediately on the syntax — no permission-seeking, no echoing the list back as plain text.","https:\u002F\u002Fgithub.com\u002Flaurac8r\u002Fclaude-damn\u002Fblob\u002Fmain\u002Fskills\u002Ftask-list\u002FSKILL.md",[],[162,145,163,164,29,148,101,27,165,166,167,168,169,170],"task list","list","display","permission","back","flags","syntax","text","update",{"skillNo":172,"name":173,"nameZh":6,"description":174,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":175,"categories":176,"keywords":177,"publishedAt":32},"01M6K5T8CER0BAPJVJDG5F5GD0","sync","Sync files between two local directories, repos, or git worktrees. Five modes (plan\u002Finteractive\u002Fpush\u002Fpull\u002Fmirror), .gitignore-aware, Claude-workflow allowlist via --claude, dropbox-restore-style per-directory prompts.","https:\u002F\u002Fgithub.com\u002Flaurac8r\u002Fclaude-damn\u002Fblob\u002Fmain\u002Fskills\u002Fsync\u002FSKILL.md",[],[173,178,179,146,29,180,181,182,183,184,185,186,187,188,189,190,191,192,193,154],"git worktrees","mirror","limit","yes","directories","dry","local","gitignore","restore","files","modes","interactive","plan","push","pull","delete",{"skillNo":195,"name":196,"nameZh":6,"description":197,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":198,"categories":199,"keywords":200,"publishedAt":32},"01M6K5T2S3J291RE2B2GW7J43H","super","Brainstorming (alias for \u002Fbrainstorming)","https:\u002F\u002Fgithub.com\u002Flaurac8r\u002Fclaude-damn\u002Fblob\u002Fmain\u002Fskills\u002Fsuper\u002FSKILL.md",[],[196,31,29,201,145,202],"alias","brainstorming"]