Skip to content

/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".

shell
$ npx -y skills add wayne930242/Reflexive-Claude-Code --skill applying-agent-systems --agent claude-code

How 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
How auto-invocation works

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.md
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. |

Read more
Read it on GitHub ↗
Ships withreflexive-claude-code

A Claude Code plugin marketplace for skills-driven Agentic Context Engineering (ACE) — build, analyze, and maintain agent systems with structured workflows.

Get the whole plugin, auto-invoked