reality-check

Score project claims against implementation evidence and generate a findings report.

3|Updated Apr 5, 2026
One-click install
npx skills add https://github.com/dvy1987/agent-loom --skill reality-check-dvy1987
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: reality-check
Source: https://github.com/dvy1987/agent-loom/tree/main/.agents/skills/reality-check
Command: npx skills add https://github.com/dvy1987/agent-loom --skill reality-check-dvy1987

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Reality-checks a project by comparing what it claims to do against what it actually implements, turning marketing, README, and product claims into evidence-backed judgments so stakeholders can trust the true surface area of the product.

Core Features & Use Cases

  • Claims extraction: Enumerates explicit and implicit claims from README, PRD, and marketing docs.
  • Evidence gathering: Reads source code, tests, commit history, and execution artifacts to verify each claim.
  • Scoring & classification: Scores claims (1–10) across implementation, execution proof, tests, scalability, documentation, and dependency risk, and classifies architectural gaps by severity.
  • Deliverables: Produces a findings report and a sequenced roadmap saved under docs/, and appends an entry to docs/skill-outputs/SKILL-OUTPUTS.md.
  • Use case: Investor due diligence, internal product audit, competitor claims validation, or pre-release credibility checks.

Quick Start

Ask the skill to reality-check the repository and produce a findings report plus an actionable roadmap saved to docs/.

Frequently Asked Questions about reality-check

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

FAQPage Schema
How do I verify a repository's claims against actual implementation for due diligence?

You can validate project claims by evaluating README and marketing docs against source code, tests, and commit history. This claims assessment scores truthfulness across implementation, execution proof, and documentation to expose architectural gaps.

How does claims assessment work for competitive analysis of a codebase?

Claims assessment for competitive analysis works by enumerating product claims, reading execution artifacts and source code, and scoring each claim from 1 to 10 across implementation, scalability, and dependency risk to produce an evidence-cited findings report.

What is the best way to audit a codebase for pre-release credibility checks?

The best way to audit codebase credibility is performing a technical audit that reads repository artifacts, classifies architectural gaps by severity, and generates a sequenced roadmap saved into the docs directory to address discovered implementation issues.

Do I need repository read access to perform a technical audit of product claims?

Yes, you need repository read access to source, tests, logs, and docs to perform a technical audit. This access allows the evaluation to gather evidence from implementation and execution artifacts to verify claims and score product credibility.

Can I use this approach to evaluate architectural gaps and dependency risk?

Yes, you can evaluate architectural gaps and dependency risk by scoring claims across implementation, tests, scalability, and documentation. The evaluation classifies gaps by severity and generates an actionable roadmap saved under docs/.

What limitations exist when evaluating commit history and execution artifacts for claims validation?

A limitation of evaluating commit history and execution artifacts is that the technical audit requires accessible source code and logs to verify claims. Without complete repository artifacts, the evaluation cannot fully score implementation proof or generate a comprehensive findings report.