/applying-agent-systems
Builds agent system components from a confirmed component plan. Use when executing a component plan to build agent system elements. Use when called by planning-agent-systems after plan is confirmed. Use when user says "apply agent plan", "build agent system".
$ npx -y skills add wayne930242/Reflexive-Claude-Code --skill applying-agent-systems --agent claude-codeHow it fires
How this skill gets triggered: by you, by Claude, or both.
- Fires itselfAuto-invocation. Claude auto-loads it when your prompt matches the work.
- You can call itInvoke it directly when you want it.
- Slash command
/applying-agent-systems
Context preview
The summary Claude sees to decide when to auto-load this skill.
Builds agent system components from a confirmed component plan. Use when executing a component plan to build agent system elements. Use when called by planning-agent-systems after plan is confirmed. Use when user says "apply agent plan", "build agent system".
SKILL.md
applying-agent-systems.SKILL.mdname: applying-agent-systems
description: Builds agent system components from a confirmed component plan. Use when executing a component plan to build agent system elements. Use when called by planning-agent-systems after plan is confirmed. Use when user says "apply agent plan", "build agent system".
Applying Agent Systems
Overview
**Applying agent systems IS orchestrating writing-* skill invocations in the correct order.**
Read the component plan, invoke the appropriate writing-* skill for each component, verify each one succeeds before moving to the next.
**Core principle:** Never create components directly. Always invoke the writing-* skill. Skills encode best practices that direct creation bypasses.
Routing
**Pattern:** Chain **Handoff:** user-confirmation **Next:** `reviewing-agent-systems` **Chain:** main
Task Initialization (MANDATORY)
Follow [task initialization protocol](../../references/task-initialization.md).
**Tasks:** 1. Read component plan 2. Execute component creation (one task per component from plan) 3. Verify system integration
Announce: "Created N tasks. Starting execution..."
Task 1: Read Component Plan
**Goal:** Load the component plan and prepare execution order.
**Read:** `.rcc/*-plan.md` (most recent)
**Create a TaskCreate for each component** in the plan's execution order:
- "[applying] Create CLAUDE.md"
- "[applying] Create rule: [name]"
- "[applying] Create hook: [name]"
- etc.
**Verification:** All components from plan have corresponding tasks.
Task 2+: Execute Component Creation
**Goal:** For each component in order, invoke the correct writing-* skill.
**Execution order (MUST follow):** 1. CLAUDE.md → invoke `writing-claude-md` 2. Rules → invoke `writing-rules` (one per rule) 3. Hooks → invoke `writing-hooks` (one per hook) 4. Skills → invoke `writing-skills` (one per skill) 5. Agents → invoke `writing-subagents` (one per agent)
**For each component:** 1. Invoke the writing-* skill with the plan's specifications 2. Wait for skill to complete 3. Verify the component was created correctly 4. Mark task complete 5. Move to next component
**Important constraints:**
- **All writes happen in main conversation.** NEVER delegate writing-* skill invocations to subagents. Subagents cannot reliably write to `.claude/` directories.
- **One component at a time.** Don't batch. Each writing-* skill has its own creation process.
- **Pass plan context.** When invoking a writing-* skill, provide the relevant section from the component plan as context.
**Verification:** Each component exists and passes the writing-* skill's own validation.
Final Task: Verify System Integration
**Goal:** Verify all components work together.
**Checklist:**
- [ ] CLAUDE.md exists and is under 200 lines
- [ ] All planned rules exist with correct `paths:` globs
- [ ] All planned hooks are registered in `.claude/settings.json`
- [ ] Hooks return correct exit codes (test with sample input)
- [ ] All planned skills have valid frontmatter
- [ ] No conflicts between CLAUDE.md and rules
- [ ] No duplicate logic across components
**Handoff:** "所有元件已建立並驗證。要進行品質審查嗎?"
- If yes → invoke `reviewing-agent-systems` skill
**Verification:** All checklist items pass.
Red Flags - STOP
These thoughts mean you're rationalizing. STOP and reconsider:
- "I can write this component directly, skip the writing-* skill"
- "Dispatch a subagent to write the rule"
- "Create multiple components in parallel"
- "Skip verification, the writing-* skill handles it"
- "Deviate from the plan, I have a better idea"
**All of these mean: You're about to bypass quality gates. Follow the process.**
Common Rationalizations
| Excuse | Reality | |--------|---------| | "Write directly" | Writing-* skills encode structured process + review. Bypass = weak components. | | "Use subagent" | Subagents can't write to `.claude/`. Will silently fail. | | "Parallel creation" | Components depend on each other. CLAUDE.md before rules before hooks. | | "Skip verification" | Integration issues only appear when components interact. Verify. | | "Better idea" | The plan was user-approved. Discuss changes, don't silently deviate. |
Read more
name: applying-agent-systems description: Builds agent system components from a confirmed component plan. Use when executing a component plan to build agent system elements. Use when called by planning-agent-systems after plan is confirmed. Use when user says "apply agent plan", "build agent system".
Applying Agent Systems
Overview
**Applying agent systems IS orchestrating writing-* skill invocations in the correct order.**
Read the component plan, invoke the appropriate writing-* skill for each component, verify each one succeeds before moving to the next.
**Core principle:** Never create components directly. Always invoke the writing-* skill. Skills encode best practices that direct creation bypasses.
Routing
**Pattern:** Chain **Handoff:** user-confirmation **Next:** `reviewing-agent-systems` **Chain:** main
Task Initialization (MANDATORY)
Follow [task initialization protocol](../../references/task-initialization.md).
**Tasks:** 1. Read component plan 2. Execute component creation (one task per component from plan) 3. Verify system integration
Announce: "Created N tasks. Starting execution..."
Task 1: Read Component Plan
**Goal:** Load the component plan and prepare execution order.
**Read:** `.rcc/*-plan.md` (most recent)
**Create a TaskCreate for each component** in the plan's execution order:
- "[applying] Create CLAUDE.md"
- "[applying] Create rule: [name]"
- "[applying] Create hook: [name]"
- etc.
**Verification:** All components from plan have corresponding tasks.
Task 2+: Execute Component Creation
**Goal:** For each component in order, invoke the correct writing-* skill.
**Execution order (MUST follow):** 1. CLAUDE.md → invoke `writing-claude-md` 2. Rules → invoke `writing-rules` (one per rule) 3. Hooks → invoke `writing-hooks` (one per hook) 4. Skills → invoke `writing-skills` (one per skill) 5. Agents → invoke `writing-subagents` (one per agent)
**For each component:** 1. Invoke the writing-* skill with the plan's specifications 2. Wait for skill to complete 3. Verify the component was created correctly 4. Mark task complete 5. Move to next component
**Important constraints:**
- **All writes happen in main conversation.** NEVER delegate writing-* skill invocations to subagents. Subagents cannot reliably write to `.claude/` directories.
- **One component at a time.** Don't batch. Each writing-* skill has its own creation process.
- **Pass plan context.** When invoking a writing-* skill, provide the relevant section from the component plan as context.
**Verification:** Each component exists and passes the writing-* skill's own validation.
Final Task: Verify System Integration
**Goal:** Verify all components work together.
**Checklist:**
- [ ] CLAUDE.md exists and is under 200 lines
- [ ] All planned rules exist with correct `paths:` globs
- [ ] All planned hooks are registered in `.claude/settings.json`
- [ ] Hooks return correct exit codes (test with sample input)
- [ ] All planned skills have valid frontmatter
- [ ] No conflicts between CLAUDE.md and rules
- [ ] No duplicate logic across components
**Handoff:** "所有元件已建立並驗證。要進行品質審查嗎?"
- If yes → invoke `reviewing-agent-systems` skill
**Verification:** All checklist items pass.
Red Flags - STOP
These thoughts mean you're rationalizing. STOP and reconsider:
- "I can write this component directly, skip the writing-* skill"
- "Dispatch a subagent to write the rule"
- "Create multiple components in parallel"
- "Skip verification, the writing-* skill handles it"
- "Deviate from the plan, I have a better idea"
**All of these mean: You're about to bypass quality gates. Follow the process.**
Common Rationalizations
| Excuse | Reality | |--------|---------| | "Write directly" | Writing-* skills encode structured process + review. Bypass = weak components. | | "Use subagent" | Subagents can't write to `.claude/`. Will silently fail. | | "Parallel creation" | Components depend on each other. CLAUDE.md before rules before hooks. | | "Skip verification" | Integration issues only appear when components interact. Verify. | | "Better idea" | The plan was user-approved. Discuss changes, don't silently deviate. |
A Claude Code plugin marketplace for skills-driven Agentic Context Engineering (ACE) — build, analyze, and maintain agent systems with structured workflows.
Repo: wayne930242/Reflexive-Claude-Code
Other skills on reflexive-claude-code.
- /analyzing-codebases
Detects project languages and monorepo state, runs language-appropriate static analysis (dependency graph, complexity, duplication, semantic patterns), and produces a refactor map ranking hotspots. Use when user invokes /aref or explicitly asks to analyze a codebase for
Open skill - /applying-refactors
Executes a refactor plan phase-by-phase on a dedicated branch with per-phase commits and mandatory reviewer checkpoints. Use when characterization-tests scaffold is complete and plan has phases ready to execute.
Open skill - /finalizing-refactors
Writes AGENTS.md per subproject, archives run artifacts, and suggests rcc handoff conditionally. Use when verifying-refactors passes (PASS or PASS-WITH-WEAK-TESTS).
Open skill - /planning-refactors
Converts a refactor map into a phased plan using parallel-change, branch-by-abstraction, or strangler fig patterns. Use when user has approved the refactor map from analyzing-codebases.
Open skill - /scaffolding-characterization-tests
Adds golden/snapshot tests to untested hotspot modules before refactoring. Use when refactor plan marks any phase with characterization_test.status=must-scaffold.
Open skill - /verifying-refactors
Validates hard structural rules (no cycles, file/fn line caps, cognitive/cyclomatic complexity) and runs mutation testing on touched modules. Use when applying-refactors has completed all phases on the refactor branch.
Open skill

