Ambiguous requirements create conflicting implementations and unverifiable reviews. This skill guides linked specifications, risk assessments, and verification strategies through explicit human approval.

Implementation reviews lose traceability when findings exist only in conversation. This skill structures task, fix, and branch reviews around contract references and persistent verdict files.

Separate plans can hide missing requirements, incompatible interfaces, and broken dependencies. This skill reviews the complete plan set and coordinates repairs with independent verification.

Incomplete implementation plans leave developers guessing about interfaces, dependencies, and acceptance criteria. This skill structures approved specifications into traceable tasks with explicit tests and execution gates.

Unclear scope and missing approval records make project decisions difficult to track. This skill guides request classification, charter writing, and lifecycle documentation through Executor.

Session changes can lose decisions, verification evidence, and unfinished implementation work. This skill guides human-controlled integration, durable pause records, and resumption checked against the current repository.

Long implementation plans can lose task state and accumulate unreviewed changes. This skill coordinates scoped subagents, review gates, and durable records across execution and recovery.

Unclear requirements and unsupported assumptions make technical decisions difficult. This skill guides structured discovery, evidence gathering, and approach comparisons before human approval.

Conflicting documents can carry incorrect decisions into later development phases. This skill coordinates independent audits, scoped repairs, and fresh re-audits before phase clearance.

Rough feature ideas can become specifications before alternatives and failure cases are examined. This skill structures research, independent concepts, critique, and human decisions into a recorded design.

Vague architecture leaves teams with incompatible interfaces and undocumented decisions. This skill structures architecture, decisions, contracts, and component designs for human review before specification.

Long coding projects lose context, decisions, and review evidence across sessions. Executor records initiative state and coordinates phase routing, task dispatch, and approval gates.

NestJS changes can introduce incompatible syntax, hidden side effects, and public API regressions. This skill guides repository inspection, focused implementation, and evidence-based verification.

Unclear responsibilities and unnecessary abstractions make NestJS code difficult to change and test. This skill guides evidence-based object design, pattern selection, and behavior-preserving refactoring.

Mixed changes and unclear publication requests can produce misleading commits or unintended remote updates. This skill guides verified Git changes and accurate messages within authorized scope.

NestJS runtime changes can create latency, security, and deployment failures when teams lack clear contracts and measurements. This skill guides component selection, bottleneck diagnosis, and reliable implementation using repository evidence and focused tests.

Source code alone cannot establish whether a NestJS feature satisfies its roadmap. This skill compares requirements with revision-specific evidence and reports completed work, gaps, legacy paths, bugs, and blockers.

NestJS repositories can hide boundary flaws and runtime risks that lint results alone cannot reveal. This skill combines local evidence collection and semantic review into one prioritized report.

Unclear module boundaries make NestJS changes harder to test and coordinate. This skill guides evidence-based architecture decisions, explicit ownership, and incremental boundary repairs.

Many application features need semantic judgments, but free-form model responses are difficult to combine reliably in code. TypeSafe helps developers design small typed judgments and compose them into routing, ranking, extraction, verification, and interactive workflows.