Analyze Before You Implement: The Pre-Code Consistency Gate

Where this fits

You've just finished writing your spec, plan, and task list. Your agent is about to start implementing, but you have a nagging feeling the plan doesn't match the spec's constraints. That's the moment analyze steps in—it cross-reads your constitution, spec, plan, and tasks against each other before a single line of code is written. It's the cheapest place to catch a problem: a contradiction found here costs a sentence; the same contradiction found mid-implement costs a rewrite.

Why agents benefit

• Catches contradictions between the constitution's principles and the spec's requirements before they become technical debt.
• Identifies coverage gaps where the plan omits a required feature from the spec, so you can fix the plan before coding.
• Flags duplication across tasks, preventing wasted compute on redundant work.
• Detects scope drift when tasks introduce features never mentioned in the spec, keeping the implementation aligned with intent.
• Produces a structured report without editing any files, giving you a clear decision point before the irreversible part of the build.

Practical scenarios

Mid-project spec revision

The spec changed after the plan was written. analyze highlights which tasks no longer align with the updated spec, saving you from implementing obsolete work. You can re-plan only the affected sections instead of guessing.

Multi-agent handoff

Two agents wrote the plan and tasks separately. analyze checks their consistency before merging, preventing integration chaos. It surfaces where one agent's assumptions contradict the other's, so you can reconcile early.

Pre-implementation audit

You want a final sanity check before committing to a long implementation. analyze runs a quick cross-read and gives you confidence that nothing is missing. It's the gate that ensures you're building the right thing, right.

Add it to your agent workflow

Install it with:

npx skills add ericrisco/rsc-harness --skill analyze

Once added, your agent can invoke analyze with the four artifacts as input. The skill returns a structured report of gaps, contradictions, and duplications—no file edits, no ambiguity resolution, just the facts. Wire it into your pipeline right before implement, and you'll catch most issues before they cost you hours.

Compare before adopting

Before adopting, check the repo's commit history and issue tracker—the skill is part of a larger harness (rsc-harness) with 58 stars, so look for recent activity. Compare it with manual review or other consistency-checking tools. Consider whether your workflow already has a gate between tasks and implementation; if not, this skill adds a useful checkpoint. Also, note that analyze is not a substitute for clarify—it reports ambiguity but doesn't resolve it.

Why it is worth tracking

With 58 stars and a clear position in the rsc-sdd chain, analyze is a focused tool that solves a real problem. It's worth tracking because it represents a shift toward pre-implementation validation in agent workflows. If you're building agents that generate code from specs, this skill is a cheap insurance policy. You can explore its details on OpenAgentSkill to see community feedback and usage examples. Evaluate it when you find yourself manually cross-checking documents before a build—that's the moment it pays for itself.