rootnode-domain-content-communications
Specialized prompt methodology for writing, editing, content strategy, copywriting, audience analysis.
Claude environments are architecture.
Build them like it
A tested system of modular Skills that score, diagnose, and build Claude architecture from reusable components.
27 Skills · 92 Blocks · Open Source ·
01 — The problem
How well is your Claude environment actually performing?
The Claude ecosystem has a layered architecture. How content is distributed across those layers determines whether Claude performs at its potential or works against itself. The hard part isn't building a Project or wiring a Claude Code repo — it's seeing what's quietly working against you.
Architectural inefficiencies don't announce themselves. They surface as vague symptoms: output that drifts, instructions that get ignored intermittently, quality that degrades over long conversations, autonomous agents that escalate work they shouldn't or barrel through halts they should respect. These Skills surface those structural issues, triage them by impact, and produce targeted fixes.
They treat the entire ecosystem as a unified system — scoring each layer, detecting cross-layer conflicts, diagnosing behavioral tendencies, gating handoffs to autonomous execution, and building Projects and Claude Code environments that are structurally sound from the start.
02 — The architecture
Two surfaces. Four scopes.
Two surfaces, layered architecture across each. Skills are mapped to the layers they impact — a Skill that builds knowledge files appears on the Knowledge Files layer because that's the layer it modifies; a Skill that audits five layers at once appears on each of them.
One Skill spans Global and Project scopes. rootnode-full-stack-audit runs Project audit + Global audit + Cross-Layer Alignment in a single pass — the only Skill in the catalog that audits two scopes together rather than within one.
GLOBAL SCOPE
Foundation across all Projects · shared by every conversation
PROJECT SCOPE
Shapes every conversation in a Project
CONVERSATION SCOPE
The current exchange
↪ BRIDGES
connect Projects and conversations across the chat-side ecosystem
↘ CROSS-BOUNDARY
live in chat-Projects and prepare handoffs to Claude Code
CLAUDE CODE
the execution layer
⇄ DUAL-SURFACE
Skills that operate in both chat-Projects and Claude Code
03 — The skills
Diagnose. Build. Optimize.
27 Skills published on GitHub. Each works independently. Install one or install all — they compose additively without competing.
Core Skills
These operate directly on the architectural layers. Primary tools for building, diagnosing, and maintaining Claude environments across both surfaces.
Build
| Skill | Tier | Surface | What it does |
|---|---|---|---|
rootnode-prompt-compilation | T3 | Chat | Builds complete prompts and scaffolds Claude Projects via a four-stage Parse/Select/Construct/Validate pipeline. |
rootnode-skill-builder | T2 | Both ⇄ | Builds deployment-ready Skill packages from design specs. Six workflows: build, iterate, optimize, compare, review, revise. |
rootnode-cc-design | T3 | Both ⇄ | Designs Claude Code environments across five modes: design, evolve, research, template, remediate. |
Diagnose
| Skill | Tier | Surface | What it does |
|---|---|---|---|
rootnode-project-audit | T3 | Chat | Scores a Claude Project on six dimensions, surfaces structural issues, and prescribes targeted fixes. |
rootnode-global-audit | T3 | Chat | Audits all five global layers using a six-dimension scorecard and detects cross-layer failure modes. |
rootnode-anti-pattern-detection | T2 | Chat | Detects seven structural anti-patterns that cause ignored instructions and degraded output. |
rootnode-prompt-validation | T2 | Chat | Scores prompts on six dimensions and maps each weakness to a structural fix. |
rootnode-repo-hygiene | T3 | Code | Audits a Claude Code deployment via 14-category sweep, 7-layer leak check, and anti-pattern detection. |
Optimize
| Skill | Tier | Surface | What it does |
|---|---|---|---|
rootnode-behavioral-tuning | T2 | Chat | Diagnoses ten Claude behavioral tendencies and supplies countermeasure templates. |
rootnode-memory-optimization | T2 | Chat | Rebalances content across Memory, Custom Instructions, knowledge files, and User Preferences with edit prescriptions. |
rootnode-context-budget | T3 | Chat | Analyzes context budget across two pools with per-file evaluation, content routing, and phased optimization. |
Cross-Layer
| Skill | Tier | Surface | What it does |
|---|---|---|---|
rootnode-full-stack-audit | T3 | Chat | Runs Project audit + Global audit + Cross-Layer Alignment in one pass and produces a unified impact-ordered action plan. |
Bridge
| Skill | Tier | Surface | What it does |
|---|---|---|---|
rootnode-project-brief | T1 | Chat | Generates an uploadable Project Brief — goals, architecture, knowledge files, instructions, Memory, and key decisions. |
rootnode-session-handoff | T1 | Chat | Produces a session continuation document capturing active work, decisions, files, knowledge, and open items. |
Cross-Boundary
| Skill | Tier | Surface | What it does |
|---|---|---|---|
rootnode-handoff-trigger-check | T1 | Chat | Evaluates handoff readiness via a 7-condition gate and returns a structured JSON verdict. |
rootnode-profile-builder | T1 | Chat | Builds schema-validated configuration profiles via progressive-depth interview; consumed by mode-router and critic-gate. |
Runtime
| Skill | Tier | Surface | What it does |
|---|---|---|---|
rootnode-critic-gate | T2 | Code | Profile-driven gate that evaluates work against thresholds before merge, returning a structured verdict. |
rootnode-mode-router | T1 | Code | Profile-driven router that dispatches Claude Code work by strictness, scope, or context. |
Supporting Skills
These activate automatically when Core Skills need them. They provide the specialized methodology the Compiler and audit tools draw on during assembly and evaluation.
Block Libraries
| Skill | Tier | Surface | What it does |
|---|---|---|---|
rootnode-block-selection | T2 | Chat | Decision-tree router that picks the right identity, reasoning, and output approach per task. |
rootnode-identity-blocks | T1 | Chat | Catalog of 8 tested identity approaches for shaping Claude's expertise orientation. |
rootnode-reasoning-blocks | T1 | Chat | Catalog of 18 reasoning variants across Analytical, Strategic, Creative, Technical, Research, and Comparative categories. |
rootnode-output-blocks | T1 | Chat | Catalog of 10 tested output format specifications for structured deliverables. |
Domain Packs
| Skill | Tier | Surface | Domain |
|---|---|---|---|
rootnode-domain-business-strategy | T1 | Chat | Specialized prompt methodology for consulting, competitive analysis, corporate strategy, and M&A. |
rootnode-domain-software-engineering | T1 | Chat | Specialized prompt methodology for system design, code review, incident response, security, and API work. |
rootnode-domain-content-communications | T1 | Chat | Specialized prompt methodology for writing, editing, content strategy, copywriting, and persuasion. |
rootnode-domain-research-analysis | T1 | Chat | Specialized prompt methodology for data analysis, policy research, evidence synthesis, and systematic review. |
rootnode-domain-agentic-context | T1 | Chat | Specialized prompt methodology for AI agent design, tool interfaces, context architecture, and multi-agent coordination. |
04 — In practice
What it looks like to use root.node.
| You say | What happens |
|---|---|
| "Build me a Claude Project for our engineering team's code review workflow." | Compilation builds the full scaffold — Custom Instructions, knowledge file architecture, global layer advisory. The software engineering domain pack provides specialized approaches. |
| "Audit my project. Output quality has been inconsistent." | Project audit scores six dimensions, detects anti-patterns, and produces prioritized fixes grounded in evidence from your Project. |
| "Run a full stack audit of everything — my project and my global setup." | Full-stack audit runs both Project and Global scorecards, checks cross-layer alignment across all nine layers, and produces a unified action plan. |
| "Design a Claude Code environment for our deployment automation repo." | cc-design DESIGN mode produces a CLAUDE.md draft with R1–R5 required sections, agent topology, scope authorization clauses, halt-and-escalate triggers, and a Skills/hooks/MCP plan tuned to the repo. |
| "Are we ready to hand this off to Claude Code?" | handoff-trigger-check walks the 7-condition gate (spec stability, verification surface, invariants, pump-primer, work decomposition, rollback cost, token budget) and returns a structured verdict with what's missing. |
| "Run a hygiene check on this Claude Code repo." | repo-hygiene runs the 14-category sweep, 7-layer leak check, and anti-pattern detection. Produces HYGIENE_REPORT.md ready for cc-design REMEDIATE mode to consume. |
| "Capture this Project's context so I can use it in another Project." | Project brief generates a structured upload-ready document with the Project's goals, architecture, knowledge files, instructions summary, and key decisions. |
More examples
| You say | What happens |
|---|---|
| "Wrap up this session. Build a handoff for the next conversation." | Session handoff captures active work streams, decisions with rationale, open items, and a starter prompt for the next conversation. |
| "Build me a Claude Project for an agent that does research and writes reports." | Compilation builds the full scaffold. The agentic domain pack provides agent-specific methodology: tool interface design, context architecture, failure mode planning. |
| "What's wrong with my project? Claude keeps ignoring my instructions." | Anti-pattern detection checks for seven structural patterns. Every finding quotes the specific text causing the problem. |
| "Optimize my memory. I think it needs to be trimmed." | Memory optimization audits for redundancy and staleness, identifies what should be promoted to Preferences or demoted to knowledge files, and produces specific edit prescriptions. |
| "Claude keeps agreeing with everything and won't push back." | Behavioral tuning diagnoses the specific tendencies and provides countermeasure templates to deploy in Custom Instructions. |
| "Run a context budget analysis." | Runs a full context budget analysis — per-file evaluation, content routing, retrieval quality — and recommends goal-informed optimizations for your Project. |
| "Set up a critic profile for this repo's CI." | profile-builder walks an interview against the critic-gate schema, validates answers, and writes the profile. critic-gate then reads it at runtime to evaluate every change against your configured thresholds. |
| "Build this Skill from my design spec." | Skill builder converts your spec into a deployment-ready package (SKILL.md + references/ + scripts/ + agents/) following the full Skills specification, with a 9-dimension quality gate before ship. |
| "Help me pick the right reasoning approach for this analytical task." | Block selection walks the decision tree across the 18 reasoning variants and recommends the best fit with rationale. |
0
prompt blocks
0
Claude Skills
0
domain packs
0
architectural scopes
0
behavioral countermeasures
05 — Roadmap
On the horizon.
Routine deployment
Scheduled Claude Code surfaces — daily-triad and weekly-audit patterns — for continuous-watch governance instead of session-by-session invocation. Composition pattern locked; deployment in active design.
rootnode-for-code plugin
A curated bundle of the highest-impact CC Skills shipped as a single plugin install. The system without picking Skills à la carte.
Calibration Engine
Automated regression testing against new Claude model releases. Catches behavioral drift before it lands in user environments and recalibrates countermeasures across the catalog.
06 — The workflow
End-to-end optimization.
root.node covers four architectural scopes, each with its own layers. The Skills map to how the work flows. Design a Claude Project, build it out, and hand off to Claude Code when execution warrants autonomy. Design the repo, deploy, and iterate. What you learn during shipping enhances the next design pass.
root.node optimizes every step of the loop. Diagnose what's structurally working against you, build with tested components, and correct when the architecture drifts.