rootnode-domain-content-communications
Specialized prompt methodology for writing, editing, content strategy, copywriting, audience analysis.
Claude Projects are architecture.
Build them like it
A tested system of modular Skills that score, diagnose, and build Claude Project architecture from reusable components.
19 Skills · 92 Blocks · Open Source ·
01 — The problem
How well is your Claude Project actually performing?
A Claude Project that produces decent output can still be structurally unsound. There's no scorecard. No structural diagnostics. No built-in way to know whether your Project is working at 60% of its potential or 95%. root.node gives you the diagnostic tools to find out and the compilation pipeline to fix what you find.
02 — The architecture
Nine layers. One system.
Every Claude Project sits within a nine-layer architecture. Five global layers form the foundation that spans all your Projects. Three project layers shape behavior within a single Project. The conversation layer is where you interact with the system.
How content is distributed across these layers determines everything. A rule in the wrong layer gets ignored. A preference that should be global gets restated in every Project. Context budget gets consumed by content that belongs somewhere else. Cross-layer conflicts cause unpredictable output that no amount of prompt rewording will fix.
root.node treats the entire architecture as a unified system: scoring each layer, detecting cross-layer conflicts, diagnosing Claude's behavioral tendencies, and building Projects that are structurally sound from the start. The system is calibrated to how Claude actually processes context: the behavioral tendencies documented through extensive testing, the loading behavior of each layer, and the architectural patterns that produce reliable output.
The Nine Layers of a Claude Project
Click any layer for details
Cross-Layer
full-stack-audit
Spans all 9 layers in one pass
GLOBAL SCOPE
Foundation across all Projects
PROJECT SCOPE
Shapes every conversation in a Project
CONVERSATION SCOPE
The current exchange
Supporting Skills (activate in background): block-selection · identity-blocks · reasoning-blocks · output-blocks · 5 domain packs
03 — The skills
Diagnose. Build. Optimize.
Every Skill is extracted from the full root.node methodology, published on GitHub, and works independently. Install one or install all. They compose additively without competing.
The building blocks.
Block libraries provide the tested components. Domain packs add specialized methodology. Both activate automatically during compilation. You can also call them directly.
04 — In practice
What it looks like to use root.node.
Install a Skill. Talk to Claude about your Project. The right tools activate automatically.
Audit an existing Project
You say
"Audit my project"
root.node does
Ingests your Custom Instructions, knowledge files, and Memory. Scores six dimensions with anchored rubrics. Detects structural anti-patterns. Checks for behavioral miscalibrations. Cross-references global layer configuration.
You get
A scored diagnostic with the specific text causing each issue, the pattern it matches, and tested fixes ranked by impact. Act on the findings in the same conversation.
Build a new Project from scratch
You say
"Scaffold a Claude Project for competitive analysis research"
root.node does
Parses the task requirements. Selects the right identity approach, reasoning variant, and output format from the block library. Reads your global configuration to avoid redundancy. Assembles a full Project scaffold using the 5-layer prompt architecture.
You get
Complete Custom Instructions, a knowledge file architecture plan, Memory design, and a Global Layer Advisory. Validated against the six-dimension scorecard before you deploy it.
05 — The workflow
Compile, don't compose.
Traditional Project design is composition: write instructions, test them, tweak by feel, hope they hold. root.node replaces that with compilation: a structured process that assembles complete Claude Project architectures from tested components.
The Compiler
Build Projects from tested components
1
Parse
Analyze the task. What does the Project need to accomplish? What domain expertise, reasoning depth, output format, and behavioral calibration does it require? In Project Mode, the Compiler also reads your global configuration (User Preferences, installed Skills, and MCP Connectors) to inform the scaffold.
2
Select
Choose the right blocks. Decision trees map task characteristics to the best identity approach, reasoning variant, and output format from the tested library. Domain packs activate automatically for specialized tasks.
3
Construct
Assemble the Project using the 5-layer prompt architecture (Identity, Objective, Context, Reasoning, Output + Quality Control). Blocks slot into their layer. Knowledge file architecture, Memory design, and a global layer advisory are included in the scaffold.
4
Validate
Score the compiled Project against 6 quality dimensions. Check global layer alignment. Catch architectural flaws before deployment, not after.
The Optimizer
Diagnose and fix existing Projects
1
Parse
Ingest the existing Project architecture: Custom Instructions, knowledge files, Memory. For global and full-stack audits, also parse User Preferences, Styles, installed Skills, and configured MCP Connectors.
2
Diagnose
Score against the 6-dimension Project Scorecard and, for global audits, the 6-dimension Global Layer Scorecard. Detect structural anti-patterns, behavioral miscalibrations, and cross-layer failure modes, all with evidence from the Project materials.
3
Prescribe
Produce targeted fixes ranked by impact. Every prescription references the specific text causing the issue and the tested countermeasure. For full-stack audits, produce evolutionary recommendations: promotions, demotions, codifications, and Skill extractions.
4
Reconstruct
Optionally rebuild the Project architecture from the ground up using the Compiler methodology, informed by everything the diagnosis revealed.
0
prompt blocks
0
Claude Skills
0
domain packs
0
scorecard dimensions
0
behavioral countermeasures
06 — The audience
For practitioners who build with Claude.
root.node is built for people who use Claude Projects for real work. Not casual prompt experimentation. Structured, repeated workflows where output quality directly affects outcomes.
You'll get the most from these Skills if you're already building Projects and want to understand what's working, what's not, and why. Whether that means auditing a Project you've been running for months, scaffolding a new one from tested components, or diagnosing why quality degrades over long conversations.