Skillget

Reflexive-Claude-Code

agent
Guvenlik Denetimi
Uyari
Health Uyari
  • No license — Repository has no license file
  • Description — Repository has a description
  • Active repo — Last push 0 days ago
  • Community trust — 11 GitHub stars
Code Gecti
  • Code scan — Scanned 8 files during light audit, no dangerous patterns found
Permissions Gecti
  • Permissions — No dangerous permissions requested

Bu listing icin henuz AI raporu yok.

SUMMARY

A skills-driven Agentic Context Engineering workflow for Claude Code.

README.md

Reflexive Claude Code

English | 繁體中文

A skills-driven Agentic Context Engineering workflow for Claude Code with TDD-based skill design.

Core Philosophy

The agent maintains and refactors its own core prompts and agent system — not external documents or memory banks.

Skills-driven Agentic Context Engineering means:

  • Before each task, the agent reviews the skill library for relevant capabilities
  • Users explicitly trigger learning moments through skills like reflecting
  • Through deliberate teaching, the agent integrates learnings into its skill library
  • Skills are abstract, reusable, and link to reference directories with examples and documentation

What's New in v8.3.0

  • Formalized routing patterns: All 20 skills now declare their routing pattern (Tree/Chain/Node/Skill Steps)
    • New routing-patterns.md reference document with selection guide and global routing map
    • Standardized ## Routing section in every SKILL.md
    • brainstorming-workflows now teaches routing pattern selection during agent system design
    • advising-architecture decision tree includes routing pattern classification
    • weakness-checklist adds 7 routing-specific checks
    • Skill Chain Reference tables added to all entry-point skills
    • writing-plugins (rcc-dev) rewritten for full Law 7 compliance

Plugins

This marketplace provides two plugins:

rcc (v8.3.0)

Core ACE workflow with TDD-based skills, task enforcement, and quality reviewers.

Skills:

Skill Description
writing-skills TDD-based skill creation with baseline testing and review
writing-claude-md Create CLAUDE.md with standard markdown format
writing-subagents Create subagent configurations for .claude/agents/
writing-rules Create rule files for .claude/rules/ with conventions
writing-hooks Create hooks for static analysis and code quality
reflecting Reflect on conversation, classify learnings, integrate
improving-skills Optimize a skill through targeted improvements
refactoring-skills Analyze and consolidate all skills
initializing-projects Initialize new project with framework and agent system
migrating-agent-systems Route to analysis or brainstorming based on project state
analyzing-agent-systems Scan and detect weaknesses in existing agent systems
brainstorming-workflows Role-based workflow exploration for agent system design
planning-agent-systems Plan agent system components with traceability
applying-agent-systems Execute component plan via writing-* skill chain
reviewing-agent-systems Quality review with all 5 reviewer agents
refactoring-agent-systems Fix issues from review report
creating-plugins Scaffold a new Claude Code plugin
refactoring-plugins Refactor plugins against official best practices with health check
advising-architecture Validate approach, classify knowledge type, check for component conflicts

Agent System Skill Chain:

migrating-agent-systems (router)
  ├─ Existing system → analyzing-agent-systems → brainstorming-workflows → ...
  └─ New project → brainstorming-workflows → planning-agent-systems
       → applying-agent-systems → reviewing-agent-systems → refactoring-agent-systems

Subagents (Reviewers):

Agent Description
skill-reviewer Quality review for skills
claudemd-reviewer Quality review for CLAUDE.md
rule-reviewer Quality review for rules
hook-reviewer Quality review for hooks
subagent-reviewer Quality review for subagents

rcc-dev (v2.0.1)

Development helper tools for creating Claude Code plugins with complete manifests, skills, and marketplaces.

Skills:

Skill Description
writing-plugins Create complete plugin packages with manifests, skills, and marketplaces
creating-plugins Scaffold a new Claude Code plugin

Component Architecture

┌─────────────────────────────────────────────────────────────────┐
│                    Claude Code Context                          │
├─────────────────────────────────────────────────────────────────┤
│  Auto-Injected                     │  On-Demand                  │
│  ─────────────                     │  ─────────                  │
│  • CLAUDE.md (high-level)          │  • Skills (capabilities)    │
│  • .claude/rules/*.md (conventions)│  • Subagents (isolated ctx) │
│    └─ paths: conditional trigger   │                             │
└─────────────────────────────────────────────────────────────────┘
Component Location Trigger Token Impact
Rules .claude/rules/*.md Auto-inject High
Skills .claude/skills/*/SKILL.md Claude decides Progressive disclosure
Subagents .claude/agents/*.md Task tool Isolated
CLAUDE.md ./CLAUDE.md Auto-inject High

Skill Design Principles

All skills follow TDD-based design with these components:

Component Purpose
Task Initialization Mandatory TaskCreate before any action
TDD Mapping RED → GREEN → REFACTOR phases
Verification Criteria Objective checks for each task
Red Flags Anti-rationalization triggers
Rationalizations Table Counter-arguments for common excuses
Flowchart Visual process diagram
Reviewer Gate Quality review before completion

Workflow

┌─────────────────────────────────────────────────────────────────┐
│                   Work Session                                   │
├─────────────────────────────────────────────────────────────────┤
│  1. Task 1        │  Consult advising-architecture               │
│  2. RED Phase     │  Baseline test - observe failures           │
│  3. GREEN Phase   │  Create component addressing failures       │
│  4. REFACTOR      │  Quality review via reviewer subagent       │
│  5. Validate      │  Test in real usage                         │
└─────────────────────────────────────────────────────────────────┘

Installation

# From GitHub
/plugin marketplace add wayne930242/Reflexive-Claude-Code
/plugin install rcc@rcc
# or
/plugin install rcc-dev@rcc

# From local path
/plugin install /path/to/Reflexive-Claude-Code/plugins/rcc

Project Structure

Reflexive-Claude-Code/
├── .claude-plugin/
│   └── marketplace.json     # Marketplace definition
├── plugins/
│   ├── rcc/                 # Core ACE plugin
│   │   ├── skills/          # All skills
│   │   ├── agents/          # Reviewer subagents
│   │   └── commands/        # Command aliases
│   └── rcc-dev/             # Development helper plugin
└── README.md

Credits

This project's skill design patterns are inspired by:

  • superpowers - The TDD-based skill design, task enforcement, and verification patterns are adapted from the superpowers plugin by Anthropic. Special thanks for pioneering the "discipline-enforcing skill" pattern with Red Flags and Rationalization tables.

  • Agentic Context Engineering (ACE) Framework:

    Zhang, Q., Hu, C., Upasani, S., Ma, B., Hong, F., Kamanuru, V., Rainton, J., Wu, C., Ji, M., Li, H., Thakker, U., Zou, J., & Olukotun, K. (2025). Agentic Context Engineering: Evolving Contexts for Self-Improving Language Models. arXiv:2510.04618. https://arxiv.org/abs/2510.04618

License

MIT

Yorumlar (0)

Sonuc bulunamadi