Now liveThe Skillselion MCP - thousands of ranked skills, loaded into your agent mid-task. No install.Get it →
phuryn avatar

Intended Vs Implemented

  • 902 installs
  • 24.9k repo stars
  • Updated July 3, 2026
  • phuryn/pm-skills

intended-vs-implemented is a code audit skill that compares documented system intent against implementation evidence to surface requirement mismatches that linters and generic scanners miss for developers who review AI-g

About

intended-vs-implemented is a structured audit method packaged as an agent skill for finding gaps between what a system is supposed to do and what the code actually does. The skill defines what counts as documented intent, what counts as implementation evidence, which mismatches matter, and how to avoid hand-wavy findings that generic linters cannot produce because they lack an intent model. Developers reach for intended-vs-implemented when auditing AI-built code, reviewing access control against documented permissions, or checking whether a codebase still matches its own documentation. The method targets the class of bugs where code is internally consistent yet violates product or security intent. It fits pre-release reviews, compliance checks, and post-generation validation workflows where requirements live in PRDs, API docs, or permission matrices rather than only in source syntax.

  • intended-vs-implemented

Intended Vs Implemented by the numbers

  • 902 all-time installs (skills.sh)
  • +92 installs in the week ending Aug 4, 2026 (Skillselion tracking)
  • Ranked #437 of 4,347 Backend & APIs skills by installs in the Skillselion catalog
  • Data as of Aug 5, 2026 (Skillselion catalog sync)
npx skills add https://github.com/phuryn/pm-skills --skill intended-vs-implemented

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

Listed on Skillselion
Installs902
repo stars24.9k
Last updatedJuly 3, 2026
Repositoryphuryn/pm-skills

How do you audit intent versus implementation in code?

Use intended-vs-implemented for development tasks

Who is it for?

Developers auditing AI-generated codebases or access-control implementations against written requirements before merge or release.

Skip if: Teams that only need syntax linting, formatting fixes, or internal consistency checks without a documented intent model.

When should I use this skill?

A developer asks to verify code matches documentation, audit permissions against specs, or find intent gaps linters miss.

What you get

Ranked intent-versus-implementation mismatch report with evidence citations from docs and code

  • Intent-implementation mismatch report
  • Evidence-backed finding list

Files

SKILL.mdMarkdownGitHub ↗

Intended vs. Implemented: Auditing the Gap

Purpose

A linter scans code in a vacuum. It can tell you the code is internally consistent; it cannot tell you the code does what you meant, because it has no model of your intent. The highest-value security and correctness bugs live in that gap — a permission documented but never enforced, a "cron-only" endpoint anyone can call, a field marked public-only that leaks private data.

This skill is the method for finding that gap. It is the differentiator: it only works when intent has been written down first (see the shipping-artifacts skill), and that's exactly why commodity tools can't replicate it.

Context

Use this when documented intent exists — permissions.md, architecture.md, variables.md, etc. If those docs are absent or stale, that absence is itself the first finding: you cannot audit intent you never recorded. Recommend documenting first, then auditing.

Method

1. Establish intent. Read the /documentation/*.md set as the source of truth for what should be true: who may access what, which boundaries are trusted, which data is public. Treat the docs as claims to verify, not as proof.

2. Gather implementation evidence. Read the code that enforces (or fails to enforce) each claim. Evidence is a cited file and line — the actual authorization check, the actual query filter, the actual sanitizer. "It's probably handled upstream" is not evidence; the code path is.

3. Compare claim to code, one boundary at a time. For each documented rule, ask: does an enforcement point actually implement it, on the server, on every path? Distrust comments like "internal only," "admin only," or "validated elsewhere" — verify them in code.

4. Classify each mismatch by whether it matters. A mismatch matters when crossing it lets a real actor reach data, money, infrastructure, or another tenant they shouldn't. It does not matter when the only person affected is the actor themselves on their own data. Drop cosmetic drift; keep boundary-crossing drift.

5. Avoid hand-wavy findings. Every finding names: the documented intent (quote the doc), the implemented reality (cite the code), the attacker and victim, and the concrete fix. If you cannot cite both sides of the gap, it is a question to investigate, not a finding to report.

What counts

  • Intent: a documented rule, boundary, scope, or public/private classification.
  • Implementation evidence: a cited enforcement point (or its provable absence) in the code.
  • A mismatch that matters: doc says one thing, code does another, and the difference crosses a trust, cost, data, or tenant boundary.

Notes

  • Documented-but-unenforced is a finding on its own — rank it by what crossing the gap exposes.
  • Undocumented-but-enforced is usually fine, but flag it: the docs are now stale, which weakens the next audit.
  • This method feeds the security and performance audits; it does not replace their sink-level analysis — it adds the intent axis they lack.
  • Never fabricate intent to manufacture a gap. If the docs are silent, say the docs are silent.

Related skills

How it compares

Choose intended-vs-implemented over generic linters when the goal is verifying behavior against documented requirements rather than syntax or style.

FAQ

What does intended-vs-implemented audit?

intended-vs-implemented audits the gap between documented system intent and what the code actually does. The skill defines valid intent sources, implementation evidence, and which mismatches count as real findings rather than hand-wavy observations.

When should developers use intended-vs-implemented?

Developers should use intended-vs-implemented when reviewing AI-built code, validating access control against permission docs, or checking whether implementation still matches PRDs and API specifications before release.

How is intended-vs-implemented different from a linter?

A linter checks internal code consistency in isolation. intended-vs-implemented compares code behavior against an external intent model from documentation, catching requirement and permission mismatches scanners cannot infer.

Backend & APIsbackendintegrations

This week in AI coding

Five minutes, every Monday - the tools, releases and tactics for developers.

unsubscribe anytime.