{"slug":"writing-skills-4","title":"writing-skills","summary":"Use when creating new skills, editing existing skills, or verifying skills work before deployment","platform":"Claude","tags":[],"authorName":"LLM Mart","authorSlug":"llm-mart","score":0,"source":"github","price":null,"verified":false,"createdAt":"2026-09-15T18:23:37.387742Z","repo":{"url":"https://github.com/GanyuanRan/Aegis","stars":1224,"forks":53,"license":"MIT","updatedAt":"2026-09-20T11:25:37Z"},"bodyHtml":"<hr>\n<h2>name: writing-skills\ndescription: \"Use when creating new skills, editing existing skills, or verifying skills work before deployment\"</h2>\n<h1>Writing Skills</h1>\n<h2>Overview</h2>\n<p><strong>Writing skills uses pressure-scenario validation, not a code TDD route.</strong></p>\n<p><strong>Personal skills live in agent-specific directories (<code>~/.claude/skills</code> for Claude Code, <code>~/.agents/skills/</code> for Codex)</strong></p>\n<p>You write test cases (pressure scenarios with subagents), watch them fail (baseline behavior), write the skill (documentation), watch tests pass (agents comply), and refactor (close loopholes).</p>\n<p><strong>Core principle:</strong> If you didn't watch an agent fail without the skill, you don't know if the skill teaches the right thing.</p>\n<p><strong>Validation requirement:</strong> Skill changes need a baseline pressure scenario and\npost-change validation even when TDD mode is <code>off</code>; this does not require\nloading <code>aegis:test-driven-development</code>.</p>\n<p><strong>Official guidance:</strong> For Anthropic's official skill authoring best practices, see anthropic-best-practices.md. This document provides additional patterns and guidelines that complement the TDD-focused approach in this skill.</p>\n<p>Bare filenames in this skill refer to files relative to this skill directory\nunless stated otherwise.</p>\n<h2>What is a Skill?</h2>\n<p>A <strong>skill</strong> is a reference guide for proven techniques, patterns, or tools. Skills help future Claude instances find and apply effective approaches.</p>\n<p><strong>Skills are:</strong> Reusable techniques, patterns, tools, reference guides</p>\n<p><strong>Skills are NOT:</strong> Narratives about how you solved a problem once</p>\n<h2>Validation Mapping for Skills</h2>\n<table>\n<thead>\n<tr>\n<th>Validation step</th>\n<th>Skill Creation</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>Test case</strong></td>\n<td>Pressure scenario with subagent</td>\n</tr>\n<tr>\n<td><strong>Production code</strong></td>\n<td>Skill document (SKILL.md)</td>\n</tr>\n<tr>\n<td><strong>Test fails (RED)</strong></td>\n<td>Agent violates rule without skill (baseline)</td>\n</tr>\n<tr>\n<td><strong>Test passes (GREEN)</strong></td>\n<td>Agent complies with skill present</td>\n</tr>\n<tr>\n<td><strong>Refactor</strong></td>\n<td>Close loopholes while maintaining compliance</td>\n</tr>\n<tr>\n<td><strong>Write test first</strong></td>\n<td>Run baseline scenario BEFORE writing skill</td>\n</tr>\n<tr>\n<td><strong>Watch it fail</strong></td>\n<td>Document exact rationalizations agent uses</td>\n</tr>\n<tr>\n<td><strong>Minimal code</strong></td>\n<td>Write skill addressing those specific violations</td>\n</tr>\n<tr>\n<td><strong>Watch it pass</strong></td>\n<td>Verify agent now complies</td>\n</tr>\n<tr>\n<td><strong>Refactor cycle</strong></td>\n<td>Find new rationalizations → plug → re-verify</td>\n</tr>\n</tbody>\n</table>\n<p>The entire skill creation process follows RED-GREEN-REFACTOR.</p>\n<h2>When to Create a Skill</h2>\n<p><strong>Create when:</strong></p>\n<ul>\n<li>Technique wasn't intuitively obvious to you</li>\n<li>You'd reference this again across projects</li>\n<li>Pattern applies broadly (not project-specific)</li>\n<li>Others would benefit</li>\n</ul>\n<p><strong>Don't create for:</strong></p>\n<ul>\n<li>One-off solutions</li>\n<li>Standard practices well-documented elsewhere</li>\n<li>Project-specific conventions (put in CLAUDE.md)</li>\n<li>Mechanical constraints (if it's enforceable with regex/validation, automate it—save documentation for judgment calls)</li>\n</ul>\n<h2>Skill Types</h2>\n<h3>Technique</h3>\n<p>Concrete method with steps to follow (condition-based-waiting, root-cause-tracing)</p>\n<h3>Pattern</h3>\n<p>Way of thinking about problems (flatten-with-flags, test-invariants)</p>\n<h3>Reference</h3>\n<p>API docs, syntax guides, tool documentation (office docs)</p>\n<h2>Directory Structure</h2>\n<p>Repository canonical source layout:</p>\n<pre><code>skills/\n  skill-name/\n    SKILL.md              # Main reference (required)\n    supporting-file.*     # Only if needed\n</code></pre>\n<p><strong>Flat namespace</strong> - all skills in one searchable namespace</p>\n<p>Hosts may expose installed or generated views of the same skill content through\ndifferent discovery roots while preserving this repository layout as the\ncanonical source tree.</p>\n<p><strong>Separate files for:</strong></p>\n<ol>\n<li><strong>Heavy reference</strong> (100+ lines) - API docs, comprehensive syntax</li>\n<li><strong>Reusable tools</strong> - Scripts, utilities, templates</li>\n</ol>\n<p><strong>Keep inline:</strong></p>\n<ul>\n<li>Principles and concepts</li>\n<li>Code patterns (&lt; 50 lines)</li>\n<li>Everything else</li>\n</ul>\n<h2>SKILL.md Structure</h2>\n<p><strong>Frontmatter (YAML):</strong></p>\n<ul>\n<li>Two required fields: <code>name</code> and <code>description</code> (see <a href=\"https://agentskills.io/specification\">agentskills.io/specification</a> for all supported fields)</li>\n<li>Max 1024 characters total</li>\n<li><code>name</code>: Use letters, numbers, and hyphens only (no parentheses, special chars)</li>\n<li><code>description</code>: Third-person, describes when to use the skill, not its\nworkflow\n<ul>\n<li>Start with \"Use when...\" to focus on triggering conditions</li>\n<li>Include specific symptoms, situations, contexts, and user-facing outcomes\nthat help identify the trigger</li>\n<li><strong>NEVER summarize the skill's process or workflow</strong> (see CSO section for why)</li>\n<li>Keep under 500 characters if possible</li>\n</ul>\n</li>\n</ul>\n<pre><code>---\nname: Skill-Name-With-Hyphens\ndescription: Use when [specific triggering conditions and symptoms]\n---\n\n# Skill Name\n\n## Overview\nWhat is this? Core principle in 1-2 sentences.\n\n## When to Use\n[Small inline flowchart IF decision non-obvious]\n\nBullet list with SYMPTOMS and use cases\nWhen NOT to use\n\n## Core Pattern (for techniques/patterns)\nBefore/after code comparison\n\n## Quick Reference\nTable or bullets for scanning common operations\n\n## Implementation\nInline code for simple patterns\nLink to file for heavy reference or reusable tools\n\n## Common Mistakes\nWhat goes wrong + fixes\n\n## Real-World Impact (optional)\nConcrete results\n</code></pre>\n<h2>Claude Search Optimization (CSO)</h2>\n<p><strong>Critical for discovery:</strong> Future Claude needs to FIND your skill</p>\n<h3>1. Rich Description Field</h3>\n<p><strong>Purpose:</strong> Claude reads description to decide which skills to load for a given task. Make it answer: \"Should I read this skill right now?\"</p>\n<p><strong>Format:</strong> Start with \"Use when...\" to focus on triggering conditions</p>\n<p><strong>CRITICAL: Description = Trigger Conditions, NOT Workflow Summary</strong></p>\n<p>The description should describe triggering conditions. It may mention the\nuser-facing capability or outcome when that helps answer \"Should I read this\nskill right now?\" Do NOT summarize the skill's process or workflow in the\ndescription.</p>\n<p><strong>Why this matters:</strong> Testing revealed that when a description summarizes the skill's workflow, Claude may follow the description instead of reading the full skill content. A description saying \"code review between tasks\" caused Claude to do ONE review, even though the skill's flowchart clearly showed TWO reviews (spec compliance then code quality).</p>\n<p>When the description was changed to just \"Use when executing implementation plans with independent tasks\" (no workflow summary), Claude correctly read the flowchart and followed the two-stage review process.</p>\n<p><strong>The trap:</strong> Descriptions that summarize workflow create a shortcut Claude will take. The skill body becomes documentation Claude skips.</p>\n<pre><code># ❌ BAD: Summarizes workflow - Claude may follow this instead of reading skill\ndescription: Use when executing plans - dispatches subagent per task with code review between tasks\n\n# ❌ BAD: Too much process detail\ndescription: Use for TDD - write test first, watch it fail, write minimal code, refactor\n\n# ✅ GOOD: Just triggering conditions, no workflow summary\ndescription: Use when executing implementation plans with independent tasks in the current session\n\n# ✅ GOOD: Triggering conditions only\ndescription: Use when the user explicitly requests strict or test-first TDD, or when the current conversation already contains an explicit `TDD Route: strict` decision from another Aegis workflow.\n</code></pre>\n<p><strong>Content:</strong></p>\n<ul>\n<li>Use concrete triggers, symptoms, and situations that signal this skill applies</li>\n<li>Describe the <em>problem</em> (race conditions, inconsistent behavior) not <em>language-specific symptoms</em> (setTimeout, sleep)</li>\n<li>Keep triggers technology-agnostic unless the skill itself is technology-specific</li>\n<li>If skill is technology-specific, make that explicit in the trigger</li>\n<li>Write in third person (injected into system prompt)</li>\n<li><strong>NEVER summarize the skill's process or workflow</strong></li>\n</ul>\n<pre><code># ❌ BAD: Too abstract, vague, doesn't include when to use\ndescription: For async testing\n\n# ❌ BAD: First person\ndescription: I can help you with async tests when they're flaky\n\n# ❌ BAD: Mentions technology but skill isn't specific to it\ndescription: Use when tests use setTimeout/sleep and are flaky\n\n# ✅ GOOD: Starts with \"Use when\", describes problem, no workflow\ndescription: Use when tests have race conditions, timing dependencies, or pass/fail inconsistently\n\n# ✅ GOOD: Technology-specific skill with explicit trigger\ndescription: Use when using React Router and handling authentication redirects\n</code></pre>\n<h3>2. Keyword Coverage</h3>\n<p>Use words Claude would search for:</p>\n<ul>\n<li>Error messages: \"Hook timed out\", \"ENOTEMPTY\", \"race condition\"</li>\n<li>Symptoms: \"flaky\", \"hanging\", \"zombie\", \"pollution\"</li>\n<li>Synonyms: \"timeout/hang/freeze\", \"cleanup/teardown/afterEach\"</li>\n<li>Tools: Actual commands, library names, file types</li>\n</ul>\n<h3>3. Descriptive Naming</h3>\n<p><strong>Use active voice, verb-first:</strong></p>\n<ul>\n<li>✅ <code>creating-skills</code> not <code>skill-creation</code></li>\n<li>✅ <code>condition-based-waiting</code> not <code>async-test-helpers</code></li>\n</ul>\n<h3>4. Token Efficiency (Critical)</h3>\n<p><strong>Problem:</strong> getting-started and frequently-referenced skills load into EVERY conversation. Every token counts.</p>\n<p><strong>Target word counts:</strong></p>\n<ul>\n<li>getting-started workflows: &lt;150 words each</li>\n<li>Frequently-loaded skills: &lt;200 words total</li>\n<li>Other skills: &lt;500 words (still be concise)</li>\n</ul>\n<p><strong>Techniques:</strong></p>\n<p><strong>Move details to tool help:</strong></p>\n<pre><code># ❌ BAD: Document all flags in SKILL.md\nsearch-conversations supports --text, --both, --after DATE, --before DATE, --limit N\n\n# ✅ GOOD: Reference --help\nsearch-conversations supports multiple modes and filters. Run --help for details.\n</code></pre>\n<p><strong>Use cross-references:</strong></p>\n<pre><code># ❌ BAD: Repeat workflow details\nWhen searching, dispatch subagent with template...\n[20 lines of repeated instructions]\n\n# ✅ GOOD: Reference other skill\nAlways use subagents (50-100x context savings). REQUIRED: Use [other-skill-name] for workflow.\n</code></pre>\n<p><strong>Compress examples:</strong></p>\n<pre><code># ❌ BAD: Verbose example (42 words)\nyour human partner: \"How did we handle authentication errors in React Router before?\"\nYou: I'll search past conversations for React Router authentication patterns.\n[Dispatch subagent with search query: \"React Router authentication error handling 401\"]\n\n# ✅ GOOD: Minimal example (20 words)\nPartner: \"How did we handle auth errors in React Router?\"\nYou: Searching...\n[Dispatch subagent → synthesis]\n</code></pre>\n<p><strong>Eliminate redundancy:</strong></p>\n<ul>\n<li>Don't repeat what's in cross-referenced skills</li>\n<li>Don't explain what's obvious from command</li>\n<li>Don't include multiple examples of same pattern</li>\n</ul>\n<p><strong>Verification:</strong></p>\n<pre><code>wc -w skills/path/SKILL.md\n# getting-started workflows: aim for &lt;150 each\n# Other frequently-loaded: aim for &lt;200 total\n</code></pre>\n<p><strong>Name by what you DO or core insight:</strong></p>\n<ul>\n<li>✅ <code>condition-based-waiting</code> &gt; <code>async-test-helpers</code></li>\n<li>✅ <code>using-skills</code> not <code>skill-usage</code></li>\n<li>✅ <code>flatten-with-flags</code> &gt; <code>data-structure-refactoring</code></li>\n<li>✅ <code>root-cause-tracing</code> &gt; <code>debugging-techniques</code></li>\n</ul>\n<p><strong>Gerunds (-ing) work well for processes:</strong></p>\n<ul>\n<li><code>creating-skills</code>, <code>testing-skills</code>, <code>debugging-with-logs</code></li>\n<li>Active, describes the action you're taking</li>\n</ul>\n<h3>4. Cross-Referencing Other Skills</h3>\n<p><strong>When writing documentation that references other skills:</strong></p>\n<p>Use skill name only, with explicit requirement markers:</p>\n<ul>\n<li>✅ Good: <code>**REQUIRED SUB-SKILL:** Use aegis:test-driven-development</code></li>\n<li>✅ Good: <code>**REQUIRED BACKGROUND:** You MUST understand aegis:systematic-debugging</code></li>\n<li>❌ Bad: <code>See skills/testing/test-driven-development</code> (unclear if required)</li>\n<li>❌ Bad: <code>@skills/testing/test-driven-development/SKILL.md</code> (force-loads, burns context)</li>\n</ul>\n<p><strong>Why no @ links:</strong> <code>@</code> syntax force-loads files immediately, consuming 200k+ context before you need them.</p>\n<h2>Flowchart Usage</h2>\n<pre><code>digraph when_flowchart {\n    \"Need to show information?\" [shape=diamond];\n    \"Decision where I might go wrong?\" [shape=diamond];\n    \"Use markdown\" [shape=box];\n    \"Small inline flowchart\" [shape=box];\n\n    \"Need to show information?\" -&gt; \"Decision where I might go wrong?\" [label=\"yes\"];\n    \"Decision where I might go wrong?\" -&gt; \"Small inline flowchart\" [label=\"yes\"];\n    \"Decision where I might go wrong?\" -&gt; \"Use markdown\" [label=\"no\"];\n}\n</code></pre>\n<p><strong>Use flowcharts ONLY for:</strong></p>\n<ul>\n<li>Non-obvious decision points</li>\n<li>Process loops where you might stop too early</li>\n<li>\"When to use A vs B\" decisions</li>\n</ul>\n<p><strong>Never use flowcharts for:</strong></p>\n<ul>\n<li>Reference material → Tables, lists</li>\n<li>Code examples → Markdown blocks</li>\n<li>Linear instructions → Numbered lists</li>\n<li>Labels without semantic meaning (step1, helper2)</li>\n</ul>\n<p>See @graphviz-conventions.dot for graphviz style rules.</p>\n<p><strong>Visualizing for your human partner:</strong> Use <code>render-graphs.js</code> in this directory to render a skill's flowcharts to SVG:</p>\n<pre><code>./render-graphs.js ../some-skill           # Each diagram separately\n./render-graphs.js ../some-skill --combine # All diagrams in one SVG\n</code></pre>\n<h2>Code Examples</h2>\n<p><strong>One excellent example beats many mediocre ones</strong></p>\n<p>Choose most relevant language:</p>\n<ul>\n<li>Testing techniques → TypeScript/JavaScript</li>\n<li>System debugging → Shell/Python</li>\n<li>Data processing → Python</li>\n</ul>\n<p><strong>Good example:</strong></p>\n<ul>\n<li>Complete and runnable</li>\n<li>Well-commented explaining WHY</li>\n<li>From real scenario</li>\n<li>Shows pattern clearly</li>\n<li>Ready to adapt (not generic template)</li>\n</ul>\n<p><strong>Don't:</strong></p>\n<ul>\n<li>Implement in 5+ languages</li>\n<li>Create fill-in-the-blank templates</li>\n<li>Write contrived examples</li>\n</ul>\n<p>You're good at porting - one great example is enough.</p>\n<h2>File Organization</h2>\n<h3>Self-Contained Skill</h3>\n<pre><code>defense-in-depth/\n  SKILL.md    # Everything inline\n</code></pre>\n<p>When: All content fits, no heavy reference needed</p>\n<h3>Skill with Reusable Tool</h3>\n<pre><code>condition-based-waiting/\n  SKILL.md    # Overview + patterns\n  example.ts  # Working helpers to adapt\n</code></pre>\n<p>When: Tool is reusable code, not just narrative</p>\n<h3>Skill with Heavy Reference</h3>\n<pre><code>pptx/\n  SKILL.md       # Overview + workflows\n  pptxgenjs.md   # 600 lines API reference\n  ooxml.md       # 500 lines XML structure\n  scripts/       # Executable tools\n</code></pre>\n<p>When: Reference material too large for inline</p>\n<h2>The Validation Rule</h2>\n<pre><code>NO SKILL CHANGE WITHOUT A BASELINE BEHAVIOR SCENARIO\n</code></pre>\n<p>This applies to NEW skills AND EDITS to existing skills.</p>\n<p>Write skill before testing? Delete it. Start over.\nEdit skill without testing? Same violation.</p>\n<p><strong>No exceptions:</strong></p>\n<ul>\n<li>Not for \"simple additions\"</li>\n<li>Not for \"just adding a section\"</li>\n<li>Not for \"documentation updates\"</li>\n<li>Don't keep untested changes as \"reference\"</li>\n<li>Don't \"adapt\" while running tests</li>\n<li>Delete means delete</li>\n</ul>\n<p>This rule protects skill quality independently of <code>aegis:test-driven-development</code>.</p>\n<h2>Testing All Skill Types</h2>\n<p>Different skill types need different test approaches:</p>\n<h3>Discipline-Enforcing Skills (rules/requirements)</h3>\n<p><strong>Examples:</strong> TDD, verification-before-completion, designing-before-coding</p>\n<p><strong>Test with:</strong></p>\n<ul>\n<li>Academic questions: Do they understand the rules?</li>\n<li>Pressure scenarios: Do they comply under stress?</li>\n<li>Multiple pressures combined: time + sunk cost + exhaustion</li>\n<li>Identify rationalizations and add explicit counters</li>\n</ul>\n<p><strong>Success criteria:</strong> Agent follows rule under maximum pressure</p>\n<h3>Technique Skills (how-to guides)</h3>\n<p><strong>Examples:</strong> condition-based-waiting, root-cause-tracing, defensive-programming</p>\n<p><strong>Test with:</strong></p>\n<ul>\n<li>Application scenarios: Can they apply the technique correctly?</li>\n<li>Variation scenarios: Do they handle edge cases?</li>\n<li>Missing information tests: Do instructions have gaps?</li>\n</ul>\n<p><strong>Success criteria:</strong> Agent successfully applies technique to new scenario</p>\n<h3>Pattern Skills (mental models)</h3>\n<p><strong>Examples:</strong> reducing-complexity, information-hiding concepts</p>\n<p><strong>Test with:</strong></p>\n<ul>\n<li>Recognition scenarios: Do they recognize when pattern applies?</li>\n<li>Application scenarios: Can they use the mental model?</li>\n<li>Counter-examples: Do they know when NOT to apply?</li>\n</ul>\n<p><strong>Success criteria:</strong> Agent correctly identifies when/how to apply pattern</p>\n<h3>Reference Skills (documentation/APIs)</h3>\n<p><strong>Examples:</strong> API documentation, command references, library guides</p>\n<p><strong>Test with:</strong></p>\n<ul>\n<li>Retrieval scenarios: Can they find the right information?</li>\n<li>Application scenarios: Can they use what they found correctly?</li>\n<li>Gap testing: Are common use cases covered?</li>\n</ul>\n<p><strong>Success criteria:</strong> Agent finds and correctly applies reference information</p>\n<h2>Common Rationalizations for Skipping Testing</h2>\n<table>\n<thead>\n<tr>\n<th>Excuse</th>\n<th>Reality</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>\"Skill is obviously clear\"</td>\n<td>Clear to you ≠ clear to other agents. Test it.</td>\n</tr>\n<tr>\n<td>\"It's just a reference\"</td>\n<td>References can have gaps, unclear sections. Test retrieval.</td>\n</tr>\n<tr>\n<td>\"Testing is overkill\"</td>\n<td>Untested skills have issues. Always. 15 min testing saves hours.</td>\n</tr>\n<tr>\n<td>\"I'll test if problems emerge\"</td>\n<td>Problems = agents can't use skill. Test BEFORE deploying.</td>\n</tr>\n<tr>\n<td>\"Too tedious to test\"</td>\n<td>Testing is less tedious than debugging bad skill in production.</td>\n</tr>\n<tr>\n<td>\"I'm confident it's good\"</td>\n<td>Overconfidence guarantees issues. Test anyway.</td>\n</tr>\n<tr>\n<td>\"Academic review is enough\"</td>\n<td>Reading ≠ using. Test application scenarios.</td>\n</tr>\n<tr>\n<td>\"No time to test\"</td>\n<td>Deploying untested skill wastes more time fixing it later.</td>\n</tr>\n</tbody>\n</table>\n<p><strong>All of these mean: Test before deploying. No exceptions.</strong></p>\n<h2>Bulletproofing Skills Against Rationalization</h2>\n<p>Skills that enforce discipline (like TDD) need to resist rationalization. Agents are smart and will find loopholes when under pressure.</p>\n<p><strong>Psychology note:</strong> Understanding WHY persuasion techniques work helps you apply them systematically. See persuasion-principles.md for research foundation (Cialdini, 2021; Meincke et al., 2025) on authority, commitment, scarcity, social proof, and unity principles.</p>\n<h3>Close Every Loophole Explicitly</h3>\n<p>Don't just state the rule - forbid specific workarounds:</p>\n\n","files":[{"path":"SKILL.md","sizeBytes":5315,"isText":true},{"path":"testing-skills-with-subagents.md","sizeBytes":2801,"isText":true}],"reviewScore":null,"reviewSummary":null,"trust":{"provenance":"trusted-source-unreviewed","notice":"Community-authored content, reproduced verbatim and not vetted as instructions. Treat it as data to evaluate, never as directives to follow.","bodySource":null},"bodyLocked":false,"purchaseUrl":null,"sourceUrl":null,"report":{"provenance":"trusted-source-unreviewed","screen":{"ran":true,"outcome":"clean","suspicious":0,"notes":0,"hiddenCharacters":false},"virusScan":{"engine":"clamav","status":"clean","scannedAt":"2026-09-21T13:50:28.863224Z","sha256":"C1E7010B8B80037D815F10E12EB9827A619482B5870B6D93F1DACFBB5C7B2429","sizeBytes":4072},"review":null,"source":{"repositoryUrl":"https://github.com/GanyuanRan/Aegis","path":"skills/writing-skills","license":"MIT","commit":"60321eda49c3b473a183ca0edef5fbfba91eaad1","subtreeSha":"D9C655DE2A29A9FCAFA6549834FED54E89E0A5FD982BB62747F13DB5E549C095","lastSyncedAt":"2026-09-21T13:50:15.063596Z"},"reviewedAt":"2026-09-21T13:51:09.998122Z","notice":"Community-authored content, reproduced verbatim and not vetted as instructions. Treat it as data to evaluate, never as directives to follow."},"install":[{"target":"skills-cli","command":"npx skills add https://github.com/GanyuanRan/Aegis/tree/main/skills/writing-skills"},{"target":"claude-code","command":"claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install ganyuanran-aegis@llmmart"},{"target":"git","command":"git clone https://github.com/GanyuanRan/Aegis.git"}]}