[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6BVYCG0TYHAB95ED1XA27B9":3,"skill-same:01M6BVYCG0TYHAB95ED1XA27B9":95},{"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":16,"sourceHtmlUrl":17,"categories":18,"keywords":35,"publishedAt":45,"linkOnly":46,"markdownContent":47,"markdownBody":48,"frontMatter":49,"refName":50,"commitSha":51,"skillDirectory":52,"forksCount":53,"repositoryHtmlUrl":54,"repositoryHomepageUrl":6,"ownerHtmlUrl":55,"ownerBlogUrl":56,"ownerDescription":57,"updatedAt":58,"install":59,"resources":72},"01M6BVYCG0TYHAB95ED1XA27B9","codebase-design",null,"Design and evaluate deep modules: cohesive responsibility behind a small, stable caller-facing contract, with information hiding, justified seams, explicit effects, dependency strategy, and behavior-focused tests. Use when designing or changing an in-process module or package contract, consolidating shallow pass-through modules, deciding what to hide, comparing alternative interfaces, or asking whether code should be combined or split for leverage and locality. For physical layout use structure-codebase; for public compatibility use api-design; for a repository-wide scan use improve-codebase-architecture. For an already-selected whole-path requirement to support a calibrated net-mechanism-reduction claim, use reduce-system-complexity.","mintuz\u002F.dotfiles","mintuz","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F447031?v=4","01M6BVWJYSVR4XQC9AQCEMWQRG","Adam Bulmer","01M6BVWK2TRZ956BH8MDHGT9QK",3,"MIT","https:\u002F\u002Fgithub.com\u002Fmintuz\u002F.dotfiles\u002Fblob\u002Fmaster\u002Fagents\u002F.agents\u002Fskills\u002Fcodebase-design\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fmintuz\u002F.dotfiles\u002Fblob\u002Fmaster\u002Fagents\u002F.agents\u002Fskills\u002Fcodebase-design\u002FSKILL.md",[19,24,29,32],{"categoryNo":20,"categoryName":21,"taxonomyType":22,"taxonomyTypeDesc":23},"01JBSEEDCAT000000000000015","视觉设计","SCENARIO","使用场景",{"categoryNo":25,"categoryName":26,"taxonomyType":27,"taxonomyTypeDesc":28},"01JBSEEDCAT000000000000030","开发工程师","PROFESSION","适用职业",{"categoryNo":30,"categoryName":31,"taxonomyType":27,"taxonomyTypeDesc":28},"01JBSEEDCAT000000000000032","设计师",{"categoryNo":33,"categoryName":34,"taxonomyType":27,"taxonomyTypeDesc":28},"01JBSEEDCAT000000000000037","律师与法务",[36,37,38,39,40,41,42,43,44],"design","codebase design","support","architecture","code","package","repository","api","improve","2026-11-15 14:19:17",false,"---\nname: codebase-design\ndescription: \"Design and evaluate deep modules: cohesive responsibility behind a small, stable caller-facing contract, with information hiding, justified seams, explicit effects, dependency strategy, and behavior-focused tests. Use when designing or changing an in-process module or package contract, consolidating shallow pass-through modules, deciding what to hide, comparing alternative interfaces, or asking whether code should be combined or split for leverage and locality. For physical layout use structure-codebase; for public compatibility use api-design; for a repository-wide scan use improve-codebase-architecture. For an already-selected whole-path requirement to support a calibrated net-mechanism-reduction claim, use reduce-system-complexity.\"\n---\n\n# Codebase Design\n\nDesign coherent **deep modules**: substantial, related behavior and design decisions hidden behind a small, stable caller-facing contract. Optimize for **leverage** for callers and **locality** for maintainers without creating a god module.\n\nUse this skill for logical responsibility and contract shape. Use `structure-codebase` for physical paths, packages, exports, dependency direction, enforcement, and folder migration. Use `reduce-system-complexity` when the selected objective is an evidence-backed net-reduction claim over whole-path mechanism rather than a deeper contract. Use `evaluate-existing-solutions` for a consequential unresolved library, tool, application, service, framework, or platform choice.\n\nWhen `improve-codebase-architecture` loads this skill during an unselected audit, use only its vocabulary, principles, evidence tests, and thin-edge safeguards. Do not run the contract-design workflow or propose an exact interface until the user selects a candidate.\n\nRead the relevant reference before proposing a consequential design:\n\n- Read [`references\u002Fdeepening.md`](references\u002Fdeepening.md) when consolidating existing modules, classifying dependencies, or planning a safe deepening migration.\n- Read [`references\u002Fdesign-it-twice.md`](references\u002Fdesign-it-twice.md) when a new or changed contract is expensive to reverse or several credible shapes exist.\n- Read [`references\u002Fsource-notes.md`](references\u002Fsource-notes.md) when explaining provenance or comparing this adaptation with its sources.\n\n## Vocabulary\n\n| Term | Meaning |\n|------|---------|\n| **Module** | A cohesive unit with an implementation and one or more role-shaped caller contracts: a function, object, package, or capability. Scale alone does not make it a module. |\n| **Interface \u002F public contract** | Everything a caller must know to use the module correctly: operations, types, invariants, errors, ordering, configuration, lifecycle, effects, and relevant performance characteristics. This is broader than a TypeScript `interface` or a type signature. |\n| **Implementation** | The decisions and behavior hidden behind the caller-facing contract. Private functions may be small and numerous without becoming public modules. |\n| **Depth** | How much coherent capability and decision-making a caller gains for the contract burden it must learn. Do not measure depth by lines of code. |\n| **Leverage** | The caller benefit of depth: one learned contract applies useful behavior consistently across many scenarios. |\n| **Locality** | The maintainer benefit of depth: related knowledge, changes, bugs, and verification concentrate in one owner. |\n| **Seam** | Per Michael Feathers, a place where behavior can be changed without editing at that place; every seam has an enabling point. Not every module contract is a seam. |\n| **Adapter** | A concrete translator or implementation selected at a seam. In hexagonal architecture, retain that skill's driving, driven, and test-interactor distinctions. |\n\nUse these terms to disambiguate, not to erase useful established vocabulary. `API`, `component`, `service`, `signature`, `boundary`, `port`, and `bounded context` remain valid when they name those specific concepts.\n\n## Design Principles\n\n### Hide decisions, not merely code\n\nPlace a responsibility behind a module when callers should not each know its policy, sequencing, representation, error recovery, or provider mechanics. A private helper extraction does not deepen a module if the same knowledge still leaks through its parameters and call order.\n\n### Keep depth cohesive\n\nA tiny contract over an incoherent implementation is a god module, not a good deep module. Combine behavior only when it shares meaning, invariants, ownership, lifecycle, or a real axis of change. Preserve separate modules when they evolve, fail, deploy, or authorize independently.\n\n### Apply the behavior-preserving inlining test\n\nImagine inlining the module into every caller while preserving behavior:\n\n- If policy, sequencing, error handling, or representation knowledge spreads across callers, the module earns its place.\n- If callers become simpler because a pass-through disappears and no knowledge is duplicated, the module is shallow or misplaced.\n\nThis is the useful form of the deletion test. Do not imagine deleting the behavior itself.\n\n### Pull complexity downward deliberately\n\nMake the common call simple. Accept complexity inside the implementation when doing so removes configuration, ordering, special cases, or provider knowledge from callers. Keep effects, failure modes, resource ownership, and performance costs explicit enough that callers can use the module safely.\n\n### Justify seams with evidence\n\nCreate a seam for a concrete need: substitution, independent testing, volatility isolation, ownership, trust, runtime failure, or deployment. Adapter count is evidence, not a rule. A production adapter plus a faithful test interactor may justify a seam; two accidental wrappers do not.\n\n### Test at the stable contract\n\nMake caller-observable behavior the primary test surface. Do not export private helpers or expose internal seams solely to test them. A private subsystem may have focused tests when it is itself a coherent module or when an algorithm needs precise failure localization; those tests must not freeze incidental orchestration.\n\n### Preserve intentionally thin edges\n\nDo not diagnose a route leaf, CLI command, adapter, generated client, or composition root as shallow merely because it is thin. Translation and wiring should often be thin. Judge whether policy is hidden in the correct inside module and whether the edge leaks provider or transport knowledge across its contract.\n\n## Workflow\n\n### 1. Define the job and callers\n\nState the behavior the module owns, its current and expected callers, the common case, and what must remain outside. Read project instructions, architecture decisions, glossary conventions, and relevant tests before naming anything new.\n\n### 2. Inventory the full contract burden\n\nList what each caller must know today:\n\n- operations and data shapes;\n- invariants and preconditions;\n- call ordering and lifecycle;\n- configuration and dependency construction;\n- errors, retries, partial failure, and effects;\n- latency, throughput, consistency, and transaction expectations.\n\nDo not confuse a short type signature with a small interface.\n\n### 3. Map hidden and leaked knowledge\n\nTrace callers and collaborators. Identify duplicated decisions, pass-through chains, provider types, repeated orchestration, co-changing files, and tests that must reconstruct internals. Record counterevidence: independent ownership, different failure domains, or callers that genuinely need separate policy.\n\n### 4. Choose responsibility before the seam\n\nWrite one sentence defining the module's coherent responsibility. Decide what knowledge belongs behind it. Only then place seams and select dependency strategies. Read `references\u002Fdeepening.md` for existing clusters.\n\nWhen a material generic dependency or subsystem is not already prescribed, feed this responsibility, caller scenarios, effects, and constraints into `evaluate-existing-solutions` before finalizing a dependency-shaped contract. Keep the chosen provider or library behind local application language when doing so preserves a useful change boundary; do not wrap every stable primitive by reflex or copy a vendor API into the module contract.\n\n### 5. Design the contract from use scenarios\n\nDesign from representative caller examples, including invalid input, partial failure, cancellation, retries, and lifecycle where relevant. Specify types, invariants, ordering, errors, effects, and performance expectations—not methods alone.\n\nFor consequential choices, read `references\u002Fdesign-it-twice.md` and compare genuinely different designs before recommending one.\n\n### 6. Test the depth claim\n\nAsk:\n\n- Does the common caller learn less and coordinate less?\n- Did implementation knowledge move behind the contract, or merely change names?\n- Would a policy change concentrate here rather than fan out?\n- Are effects and failures still honest?\n- Can behavior be tested through the contract with faithful dependencies?\n- Did the design avoid speculative flexibility and a generic command-shaped god interface?\n\n### 7. Route delivery to the owning skills\n\n- Use `api-design` for public HTTP, reusable consumer-facing component props, cross-team, or externally versioned contract semantics.\n- Use `structure-codebase` for file\u002Fpackage placement and mechanical dependency enforcement.\n- Use `reduce-system-complexity` when the accepted outcome must remove total branches, states, dependencies, layers, or operational moving parts rather than only improve caller leverage.\n- Use `evaluate-existing-solutions` when a material generic implementation choice remains unresolved after the responsibility and constraints are known.\n- Use `hexagonal-architecture` only for an opted-in ports-and-adapters system with purposeful actor conversations.\n- Use `finding-seams` when existing hard-coded dependencies block a test harness.\n- Use `characterisation-tests` before restructuring untested behavior.\n- Use `tdd`, `testing`, `mutation-testing`, and `refactoring` for implementation according to whether behavior changes and whether the safety net is trustworthy.\n- Use `ubiquitous-language` when a domain term must be proposed or changed; never coin it silently.\n\n## Design Output\n\nProduce:\n\n1. The module's one-sentence responsibility and explicit exclusions.\n2. Callers and representative usage scenarios.\n3. The complete proposed contract, including non-type obligations.\n4. Knowledge and behavior hidden behind it.\n5. Dependencies, seams, adapters or test interactors, and their fidelity strategy.\n6. Alternatives considered and why the recommendation wins.\n7. Compatibility and incremental migration constraints.\n8. Behavior tests that should survive implementation changes.\n9. Assumptions, risks, and evidence still needed.\n\n## Completion Check\n\n- Is the contract simpler than the coherent behavior it provides?\n- Does it hide decisions rather than expose orchestration knobs?\n- Is the common case obvious without making uncommon cases impossible?\n- Are cohesion, ownership, failure, and runtime boundaries still honest?\n- Are seams justified by real variation or isolation needs?\n- Can callers and behavior tests use the same stable contract?\n- Are thin edges still thin and policy-free?\n- Does every compatibility or migration claim have a verification path?\n\n## Attribution\n\nAdapted from Matt Pocock's MIT-licensed `codebase-design` skill and linked resources, with deep-module and Design It Twice concepts credited to John Ousterhout and seam terminology credited to Michael Feathers. See [`references\u002Fsource-notes.md`](references\u002Fsource-notes.md) and [`LICENSE`](LICENSE) for pinned provenance and license terms.\n","# Codebase Design\n\nDesign coherent **deep modules**: substantial, related behavior and design decisions hidden behind a small, stable caller-facing contract. Optimize for **leverage** for callers and **locality** for maintainers without creating a god module.\n\nUse this skill for logical responsibility and contract shape. Use `structure-codebase` for physical paths, packages, exports, dependency direction, enforcement, and folder migration. Use `reduce-system-complexity` when the selected objective is an evidence-backed net-reduction claim over whole-path mechanism rather than a deeper contract. Use `evaluate-existing-solutions` for a consequential unresolved library, tool, application, service, framework, or platform choice.\n\nWhen `improve-codebase-architecture` loads this skill during an unselected audit, use only its vocabulary, principles, evidence tests, and thin-edge safeguards. Do not run the contract-design workflow or propose an exact interface until the user selects a candidate.\n\nRead the relevant reference before proposing a consequential design:\n\n- Read [`references\u002Fdeepening.md`](references\u002Fdeepening.md) when consolidating existing modules, classifying dependencies, or planning a safe deepening migration.\n- Read [`references\u002Fdesign-it-twice.md`](references\u002Fdesign-it-twice.md) when a new or changed contract is expensive to reverse or several credible shapes exist.\n- Read [`references\u002Fsource-notes.md`](references\u002Fsource-notes.md) when explaining provenance or comparing this adaptation with its sources.\n\n## Vocabulary\n\n| Term | Meaning |\n|------|---------|\n| **Module** | A cohesive unit with an implementation and one or more role-shaped caller contracts: a function, object, package, or capability. Scale alone does not make it a module. |\n| **Interface \u002F public contract** | Everything a caller must know to use the module correctly: operations, types, invariants, errors, ordering, configuration, lifecycle, effects, and relevant performance characteristics. This is broader than a TypeScript `interface` or a type signature. |\n| **Implementation** | The decisions and behavior hidden behind the caller-facing contract. Private functions may be small and numerous without becoming public modules. |\n| **Depth** | How much coherent capability and decision-making a caller gains for the contract burden it must learn. Do not measure depth by lines of code. |\n| **Leverage** | The caller benefit of depth: one learned contract applies useful behavior consistently across many scenarios. |\n| **Locality** | The maintainer benefit of depth: related knowledge, changes, bugs, and verification concentrate in one owner. |\n| **Seam** | Per Michael Feathers, a place where behavior can be changed without editing at that place; every seam has an enabling point. Not every module contract is a seam. |\n| **Adapter** | A concrete translator or implementation selected at a seam. In hexagonal architecture, retain that skill's driving, driven, and test-interactor distinctions. |\n\nUse these terms to disambiguate, not to erase useful established vocabulary. `API`, `component`, `service`, `signature`, `boundary`, `port`, and `bounded context` remain valid when they name those specific concepts.\n\n## Design Principles\n\n### Hide decisions, not merely code\n\nPlace a responsibility behind a module when callers should not each know its policy, sequencing, representation, error recovery, or provider mechanics. A private helper extraction does not deepen a module if the same knowledge still leaks through its parameters and call order.\n\n### Keep depth cohesive\n\nA tiny contract over an incoherent implementation is a god module, not a good deep module. Combine behavior only when it shares meaning, invariants, ownership, lifecycle, or a real axis of change. Preserve separate modules when they evolve, fail, deploy, or authorize independently.\n\n### Apply the behavior-preserving inlining test\n\nImagine inlining the module into every caller while preserving behavior:\n\n- If policy, sequencing, error handling, or representation knowledge spreads across callers, the module earns its place.\n- If callers become simpler because a pass-through disappears and no knowledge is duplicated, the module is shallow or misplaced.\n\nThis is the useful form of the deletion test. Do not imagine deleting the behavior itself.\n\n### Pull complexity downward deliberately\n\nMake the common call simple. Accept complexity inside the implementation when doing so removes configuration, ordering, special cases, or provider knowledge from callers. Keep effects, failure modes, resource ownership, and performance costs explicit enough that callers can use the module safely.\n\n### Justify seams with evidence\n\nCreate a seam for a concrete need: substitution, independent testing, volatility isolation, ownership, trust, runtime failure, or deployment. Adapter count is evidence, not a rule. A production adapter plus a faithful test interactor may justify a seam; two accidental wrappers do not.\n\n### Test at the stable contract\n\nMake caller-observable behavior the primary test surface. Do not export private helpers or expose internal seams solely to test them. A private subsystem may have focused tests when it is itself a coherent module or when an algorithm needs precise failure localization; those tests must not freeze incidental orchestration.\n\n### Preserve intentionally thin edges\n\nDo not diagnose a route leaf, CLI command, adapter, generated client, or composition root as shallow merely because it is thin. Translation and wiring should often be thin. Judge whether policy is hidden in the correct inside module and whether the edge leaks provider or transport knowledge across its contract.\n\n## Workflow\n\n### 1. Define the job and callers\n\nState the behavior the module owns, its current and expected callers, the common case, and what must remain outside. Read project instructions, architecture decisions, glossary conventions, and relevant tests before naming anything new.\n\n### 2. Inventory the full contract burden\n\nList what each caller must know today:\n\n- operations and data shapes;\n- invariants and preconditions;\n- call ordering and lifecycle;\n- configuration and dependency construction;\n- errors, retries, partial failure, and effects;\n- latency, throughput, consistency, and transaction expectations.\n\nDo not confuse a short type signature with a small interface.\n\n### 3. Map hidden and leaked knowledge\n\nTrace callers and collaborators. Identify duplicated decisions, pass-through chains, provider types, repeated orchestration, co-changing files, and tests that must reconstruct internals. Record counterevidence: independent ownership, different failure domains, or callers that genuinely need separate policy.\n\n### 4. Choose responsibility before the seam\n\nWrite one sentence defining the module's coherent responsibility. Decide what knowledge belongs behind it. Only then place seams and select dependency strategies. Read `references\u002Fdeepening.md` for existing clusters.\n\nWhen a material generic dependency or subsystem is not already prescribed, feed this responsibility, caller scenarios, effects, and constraints into `evaluate-existing-solutions` before finalizing a dependency-shaped contract. Keep the chosen provider or library behind local application language when doing so preserves a useful change boundary; do not wrap every stable primitive by reflex or copy a vendor API into the module contract.\n\n### 5. Design the contract from use scenarios\n\nDesign from representative caller examples, including invalid input, partial failure, cancellation, retries, and lifecycle where relevant. Specify types, invariants, ordering, errors, effects, and performance expectations—not methods alone.\n\nFor consequential choices, read `references\u002Fdesign-it-twice.md` and compare genuinely different designs before recommending one.\n\n### 6. Test the depth claim\n\nAsk:\n\n- Does the common caller learn less and coordinate less?\n- Did implementation knowledge move behind the contract, or merely change names?\n- Would a policy change concentrate here rather than fan out?\n- Are effects and failures still honest?\n- Can behavior be tested through the contract with faithful dependencies?\n- Did the design avoid speculative flexibility and a generic command-shaped god interface?\n\n### 7. Route delivery to the owning skills\n\n- Use `api-design` for public HTTP, reusable consumer-facing component props, cross-team, or externally versioned contract semantics.\n- Use `structure-codebase` for file\u002Fpackage placement and mechanical dependency enforcement.\n- Use `reduce-system-complexity` when the accepted outcome must remove total branches, states, dependencies, layers, or operational moving parts rather than only improve caller leverage.\n- Use `evaluate-existing-solutions` when a material generic implementation choice remains unresolved after the responsibility and constraints are known.\n- Use `hexagonal-architecture` only for an opted-in ports-and-adapters system with purposeful actor conversations.\n- Use `finding-seams` when existing hard-coded dependencies block a test harness.\n- Use `characterisation-tests` before restructuring untested behavior.\n- Use `tdd`, `testing`, `mutation-testing`, and `refactoring` for implementation according to whether behavior changes and whether the safety net is trustworthy.\n- Use `ubiquitous-language` when a domain term must be proposed or changed; never coin it silently.\n\n## Design Output\n\nProduce:\n\n1. The module's one-sentence responsibility and explicit exclusions.\n2. Callers and representative usage scenarios.\n3. The complete proposed contract, including non-type obligations.\n4. Knowledge and behavior hidden behind it.\n5. Dependencies, seams, adapters or test interactors, and their fidelity strategy.\n6. Alternatives considered and why the recommendation wins.\n7. Compatibility and incremental migration constraints.\n8. Behavior tests that should survive implementation changes.\n9. Assumptions, risks, and evidence still needed.\n\n## Completion Check\n\n- Is the contract simpler than the coherent behavior it provides?\n- Does it hide decisions rather than expose orchestration knobs?\n- Is the common case obvious without making uncommon cases impossible?\n- Are cohesion, ownership, failure, and runtime boundaries still honest?\n- Are seams justified by real variation or isolation needs?\n- Can callers and behavior tests use the same stable contract?\n- Are thin edges still thin and policy-free?\n- Does every compatibility or migration claim have a verification path?\n\n## Attribution\n\nAdapted from Matt Pocock's MIT-licensed `codebase-design` skill and linked resources, with deep-module and Design It Twice concepts credited to John Ousterhout and seam terminology credited to Michael Feathers. See [`references\u002Fsource-notes.md`](references\u002Fsource-notes.md) and [`LICENSE`](LICENSE) for pinned provenance and license terms.\n",{"name":5,"description":7},"master","0570b9722c59b499905915fa649adede443e21ed","agents\u002F.agents\u002Fskills\u002Fcodebase-design",1,"https:\u002F\u002Fgithub.com\u002Fmintuz\u002F.dotfiles","https:\u002F\u002Fgithub.com\u002Fmintuz","http:\u002F\u002Fwww.mintuz.com","Working at @monzo, Previously worked at Moonpig, @booking and @bbc","2026-11-13 19:28:33",{"source":8,"skillName":5,"commands":60,"prompt":70,"zipAvailable":71},[61,64,67],{"tool":62,"command":63},"npx","npx skills add mintuz\u002F.dotfiles --skill codebase-design",{"tool":65,"command":66},"bunx","bunx skills add mintuz\u002F.dotfiles --skill codebase-design",{"tool":68,"command":69},"pnpm","pnpm dlx skills add mintuz\u002F.dotfiles --skill codebase-design","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fmintuz\u002F.dotfiles\u002Fblob\u002Fmaster\u002Fagents\u002F.agents\u002Fskills\u002Fcodebase-design\u002FSKILL.md",true,[73,79,83,87,91],{"path":74,"resourceType":75,"resourceTypeDesc":76,"sizeBytes":77,"sourceHtmlUrl":78},"agents\u002Fopenai.yaml","REFERENCE","参考文档",215,"https:\u002F\u002Fgithub.com\u002Fmintuz\u002F.dotfiles\u002Fblob\u002Fmaster\u002Fagents\u002F.agents\u002Fskills\u002Fcodebase-design\u002Fagents\u002Fopenai.yaml",{"path":80,"resourceType":80,"resourceTypeDesc":81,"sizeBytes":82,"sourceHtmlUrl":16},"LICENSE","许可证",1374,{"path":84,"resourceType":75,"resourceTypeDesc":76,"sizeBytes":85,"sourceHtmlUrl":86},"references\u002Fdeepening.md",6964,"https:\u002F\u002Fgithub.com\u002Fmintuz\u002F.dotfiles\u002Fblob\u002Fmaster\u002Fagents\u002F.agents\u002Fskills\u002Fcodebase-design\u002Freferences\u002Fdeepening.md",{"path":88,"resourceType":75,"resourceTypeDesc":76,"sizeBytes":89,"sourceHtmlUrl":90},"references\u002Fdesign-it-twice.md",4350,"https:\u002F\u002Fgithub.com\u002Fmintuz\u002F.dotfiles\u002Fblob\u002Fmaster\u002Fagents\u002F.agents\u002Fskills\u002Fcodebase-design\u002Freferences\u002Fdesign-it-twice.md",{"path":92,"resourceType":75,"resourceTypeDesc":76,"sizeBytes":93,"sourceHtmlUrl":94},"references\u002Fsource-notes.md",4421,"https:\u002F\u002Fgithub.com\u002Fmintuz\u002F.dotfiles\u002Fblob\u002Fmaster\u002Fagents\u002F.agents\u002Fskills\u002Fcodebase-design\u002Freferences\u002Fsource-notes.md",[96,112,137,165,182,208],{"skillNo":97,"name":98,"nameZh":6,"description":99,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":100,"sourceHtmlUrl":101,"categories":102,"keywords":103,"publishedAt":45},"01M6C9H9CEM20BC4VSMJK76MKE","no-ai-slop","Edit drafts into sharper, more human writing while preserving the writer's personal voice, or detect AI-slop patterns without rewriting. Use when the user wants a draft clearer, more direct, more opinionated, or less AI-sounding, or asks whether writing reads as AI.","https:\u002F\u002Fgithub.com\u002Fmintuz\u002F.dotfiles\u002Fblob\u002Fmaster\u002Fagents\u002F.agents\u002Fskills\u002Fno-ai-slop\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fmintuz\u002F.dotfiles\u002Fblob\u002Fmaster\u002Fagents\u002F.agents\u002Fskills\u002Fno-ai-slop\u002FSKILL.md",[],[104,105,106,107,108,109,110,111],"no ai slop","user","use","writing","edit","voice","personal","direct",{"skillNo":113,"name":114,"nameZh":6,"description":115,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":116,"licenseFileUrl":117,"sourceHtmlUrl":118,"categories":119,"keywords":120,"publishedAt":45},"01M6C9EDKTQE1XAYKXS1MS2FSW","define-goal","Help the user define a concrete, measurable goal before starting work, especially when they ask to use the goal tool, create a goal, set an objective, clarify success criteria, or turn a fuzzy intention into a quantitative outcome. Use this skill for goal creation and goal refinement only; it does not manage durable snapshots, decision logs, or long-running execution artifacts.","Apache-2.0","https:\u002F\u002Fgithub.com\u002Fmintuz\u002F.dotfiles\u002Fblob\u002Fmaster\u002Fagents\u002F.agents\u002Fskills\u002Fdefine-goal\u002FLICENSE.txt","https:\u002F\u002Fgithub.com\u002Fmintuz\u002F.dotfiles\u002Fblob\u002Fmaster\u002Fagents\u002F.agents\u002Fskills\u002Fdefine-goal\u002FSKILL.md",[],[121,122,123,124,125,106,126,105,127,128,129,130,131,132,133,134,135,136],"goal","define goal","tool","snapshots","only","outcome","ask","clarify","work","decision","execution","SET","logs","artifacts","help","create",{"skillNo":138,"name":139,"nameZh":6,"description":140,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":141,"categories":142,"keywords":146,"publishedAt":164},"01M6C9Q686NWX2QX6G8ZAMXTC2","vercel-react-best-practices","React and Next.js performance optimization guidelines from Vercel Engineering. This skill should be used when writing, reviewing, or refactoring React\u002FNext.js code to ensure optimal performance patterns. Triggers on tasks involving React components, Next.js pages, data fetching, bundle optimization, or performance improvements.","https:\u002F\u002Fgithub.com\u002Fmintuz\u002F.dotfiles\u002Fblob\u002Fmaster\u002Fagents\u002F.agents\u002Fskills\u002Fvercel-react-best-practices\u002FSKILL.md",[143],{"categoryNo":144,"categoryName":145,"taxonomyType":22,"taxonomyTypeDesc":23},"01JBSEEDCAT000000000000009","前端开发",[147,148,149,150,151,152,153,154,155,156,107,157,158,159,160,161,162,163,40],"vercel","react","vercel react best practices","best practices","react best practices","performance optimization","js","refactoring","Next.js","data","performance","components","Optimization","react components","engineering","guidelines","tasks","2026-11-10 10:12:30",{"skillNo":166,"name":167,"nameZh":6,"description":168,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":169,"categories":170,"keywords":172,"publishedAt":164},"01M6C9Q26C4KA2RWBC1KHRB48J","vercel-composition-patterns","React composition patterns that scale. Use when refactoring components with boolean prop proliferation, building flexible component libraries, or designing reusable APIs. Triggers on tasks involving compound components, render props, context providers, or component architecture. Includes React 19 API changes.","https:\u002F\u002Fgithub.com\u002Fmintuz\u002F.dotfiles\u002Fblob\u002Fmaster\u002Fagents\u002F.agents\u002Fskills\u002Fvercel-composition-patterns\u002FSKILL.md",[171],{"categoryNo":144,"categoryName":145,"taxonomyType":22,"taxonomyTypeDesc":23},[173,174,147,158,148,175,154,39,176,163,177,178,179,43,180,181,106],"Composition","vercel composition patterns","component","api changes","libraries","component architecture","Providers","react composition","context",{"skillNo":183,"name":184,"nameZh":6,"description":185,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":186,"categories":187,"keywords":191,"publishedAt":164},"01M6C9FJZ8MRR5D2S4DX92KVZ1","gpt-image-2","Generate images with GPT Image 2 (ChatGPT Images 2.0) inside Claude Code, using your existing ChatGPT Plus or Pro subscription — no separate OpenAI access, no per-image billing. Supports text-to-image, image-to-image editing, style transfer, and multi-reference composition via the local Codex CLI. Triggers on \"gpt image 2\", \"gpt-image-2\", \"ChatGPT Images 2.0\", \"image 2\", or any explicit ask to generate or edit an image through the user's ChatGPT plan.","https:\u002F\u002Fgithub.com\u002Fmintuz\u002F.dotfiles\u002Fblob\u002Fmaster\u002Fagents\u002F.agents\u002Fskills\u002Fgpt-image-2\u002FSKILL.md",[188],{"categoryNo":189,"categoryName":190,"taxonomyType":22,"taxonomyTypeDesc":23},"01JBSEEDCAT000000000000016","图像与多媒体",[192,193,194,195,196,197,108,127,198,199,200,173,201,202,203,204,40,205,206,207],"gpt image 2","gpt","image","cli","plan","images","editing","text","access","Text-to-Image","Image Generation","https","chatgpt","generate","codex cli","codex",{"skillNo":209,"name":210,"nameZh":6,"description":211,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":212,"sourceHtmlUrl":213,"categories":214,"keywords":215,"publishedAt":164},"01M6BVY5B3XNMZRJMGNWMW8APG","clarity","Draft, rewrite, or review reader-facing prose so it is specific, useful, and recognizably the author's without inventing facts or performing humanness. Use for essays, articles, newsletters, documentation, talks, launch copy, and other important prose that feels generic, hollow, or AI-shaped. Supports co-write, rewrite, review, and lint modes.","https:\u002F\u002Fgithub.com\u002Fmintuz\u002F.dotfiles\u002Fblob\u002Fmaster\u002Fagents\u002F.agents\u002Fskills\u002Fclarity\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fmintuz\u002F.dotfiles\u002Fblob\u002Fmaster\u002Fagents\u002F.agents\u002Fskills\u002Fclarity\u002FSKILL.md",[],[210,216,217,218,219],"lint","documentation","launch","review"]