sm:stage:live-mirror

Compare specifications against produced code to identify unintended inventions.

5|2|Updated Mar 8, 2026
One-click install
npx skills add https://github.com/mnfst-ai/Stage_Manager_Skills --skill sm-stage-live-mirror
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: sm:stage:live-mirror
Source: https://github.com/mnfst-ai/Stage_Manager_Skills/tree/main/plugins/stage-manager/skills/stage-live-mirror
Command: npx skills add https://github.com/mnfst-ai/Stage_Manager_Skills --skill sm-stage-live-mirror

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

The Live Mirror exposes every decision a coding tool invented that was not explicitly specified, helping builders understand divergences between intent and implementation. It prevents hidden assumptions from becoming permanent parts of the codebase by making silent choices visible and actionable.

Core Features & Use Cases

  • Prioritized Invention Detection: Produces a ranked list of decisions the tool introduced, categorized by conflict, silent default, or reasonable fallback.
  • Spec vs. Output Comparison: Compares prompts, plans, or shaped documents against git diffs, PRs, or file outputs to quote and highlight mismatches.
  • Architectural Zone Checks: Uses reference mappings to systematically inspect all architectural areas for unintended library choices, patterns, naming, and error handling.
  • Use Case: Run after an automated coding session or pull request to decide which inventions to accept, override, or defer.

Quick Start

Run the Live Mirror with the plan file path and the git diff or PR to generate a prioritized report of invisible decisions and suggested actions.

Frequently Asked Questions about sm:stage:live-mirror

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I find invisible decisions and assumptions in a git diff after an automated coding session?

To find invisible decisions in a git diff, compare the original prompt or plan file against the produced code. This surfaces hidden assumptions, silent defaults, and unintended inventions introduced by the coding tool so you can review them before merging.

What is spec vs. output comparison in code review?

Spec vs. output comparison is the process of matching a development plan or prompt against a git diff or pull request. It systematically highlights mismatches, prioritizing architectural conflicts, default choices, and tradeoffs made during implementation.

How do I check architectural zones for unintended patterns in a pull request?

To check architectural zones in a pull request, use reference mappings to inspect code areas against the original plan. This identifies unintended library choices, naming conventions, and error handling patterns not explicitly specified in the requirements.

Can I use a prompt and a git diff to detect silent defaults in generated code?

Yes, you can use a prompt and a git diff to detect silent defaults. Comparing the explicit prompt instructions against the actual code changes reveals fallback behaviors and assumptions the coding tool invented without direct specification.

What's the best way to review unspecified library choices in a coding session output?

The best way to review unspecified library choices is to run a spec comparison against the session output. This generates a ranked report of invented decisions categorized by conflict, silent default, or reasonable fallback for you to accept or override.

When do I need to compare a specification against produced code?

You need to compare a specification against produced code during post-coding reviews and pull requests. This prevents hidden assumptions and divergences between your intent and the implementation from becoming permanent parts of the codebase.