Skip to content
Agentmart
Submit a tool

implementation-verification

Blind inference of what was implemented from code changes only.

Skill by autoencoders

IndexedCC-BY-4.0
Write a review

Chalk Labs

Need help deploying implementation-verification?

Chalk Labs sets up agents like this inside real teams: connected to your tools, tested on your data, with a human in the loop where it matters.

Book a call

Install

Works with Claude Code, Claude apps, Codex, Cursor, Gemini CLI, GitHub Copilot, VS Code, OpenCode, Goose, Windsurf. Read the repository before you give any tool access to your data.

npx agentmarket install skill/autoencoders-implementation-verification

Asks which of your tools to add it to (Claude Code, Codex, Cursor, VS Code, Windsurf, Gemini CLI, Claude Desktop) and shows the change first. See https://agentmart.dev/cli.

Get the weekly diff

The weekly diff: one email a week with new agent tools, notable updates and grade changes, plus security alerts for tools you follow. Double opt-in, one-click unsubscribe.

We use your email only for this newsletter. Privacy

About

Blind inference of what was implemented from code changes only. No access to original requirements. Produces minimal structured output for reconciliation. Triggers on "verify implementation blind", "what was built", "infer feature from changes", or as post-implementation step in feature pipeline.

Use cases: data, ml

No reviews yet. Installed it? Reviews come from verified installers only. How reviews work

Permissions

What this skill can do and what it asks for, from its SKILL.md. Checked Oct 25, 2026.

Tools
No tools found
Secrets
None asked for
Install scripts
None found

Network hosts it talks to 1

  • codeload.github.com · found in install command

Files it touches

  • ~/.claude/skills/implementation-verification

What's inside

Skill name
implementation-verification
Description
Blind inference of what was implemented from code changes only. No access to original requirements. Produces minimal structured output for reconciliation. Triggers on "verify implementation blind", "what was built", "infer feature from changes", or as post-implementation step in feature pipeline.
License
CC-BY-4.0
Instructions
161 lines in SKILL.md · view on GitHub

Files (1)

  • SKILL.md

SKILL.md (first lines)

# Implementation Verification

Infer what was built by looking only at code changes. No access to intent.

## Execution Modes

| Mode | Behavior |
|------|----------|
| `full` | Full blind inference |
| `fast` | Full blind inference |
| `prototype` | Full blind inference |
| `spike` | Skip this skill entirely |

In `spike` mode, verification is skipped. The code goes directly to the user with no validation.

## Core Constraint

**You do NOT have access to:**
- Original feature request
- Evaluation output
- Implementation plan
- Acceptance criteria

**You ONLY have access to:**
- Changed files (diffs)
- Final state of modified files
- Project structure (for context)
- Existing codebase (for context)

If someone provides feature intent, refuse it. The blindness is the point.

## What This Is (and Isn't)

**IS:** Inference snapshot — "What would a reasonable observer think this change does?"

**IS NOT:**
- QA / testing
- Correctness judgment
- Comprehensive audit

You're answering: "What was built?" not "Was it built right?"

## Banned Actions

- Reading or requesting the original requirement
- Judging whether implementation is "correct" or "wrong"
- Expanding scope beyond obvious observable behavior
- Speculating about product intent

## Output Format (Fixed, Minimal)

```
INFERENCE SNAPSHOT
══════════════════

Inferred feature (1 sentence):
[What this change appears to do, in plain language]

Observable behaviors (2-7 bullets, soft cap):
- [Behavior 1]
- [Behavior 2]
- [Behavior 3]
Overflow: [+N if needed] (justification: [why more bullets required])

Triggers / inputs (1-3 bullets):
- [How users invoke this]
- [What inputs it accepts]

Ambiguities / uncertainties (0-3 bullets):
- [Unclear what happens when X]
- [Can't tell if Y is supported]
- [Behavior not observable from changes]

Confidence: [High / Medium / Low]
If Low, reason: [Required — why evidence is weak]

Role: [Independent / Same-person]
If Same-person: [Acknowledged — completion-validation should discount]

---
Files analyzed: [count]
Lines changed: +[additions] / -[deletions]
```

## Confidence Levels

**High:** Behavior is clearly expressed in code, obvious entry points, well-named
**Medium:** Behavior is inferable but requires some interpretation
**Low:** Can't determine behavior confidently — code is unclear, internal-only, or changes are ambiguous

Low confidence requires a reason:
- "Internal refactor with no observable behavior change"
- "Behavior depends on configuration not visible in diff"
- "Code is unclear / poorly named"
- "Changes span unrelated areas"

## Soft Caps

| Field | Soft Cap | Hard Max | Overflow Allowed? |
|-------|----------|----------|-------------------|
| Observable behaviors | 7 | 10 | Yes, with justification |
| Triggers/inputs | 3 | 5 | Yes, with justification |
| Ambiguities | 3 | 3 | No — if more, confidence is Low |

## Role Separation

**Default:** Independent (different person/session than implementer)
**If waived:** Flag as "Same-person" — completion-validation discounts inference confidence

## Writing Guidelines

### Be Specific
❌ "Adds new functionality"
✓ "Adds CSV export button to report page"

### Be Observable
❌ "Improves performance" (not observable from code alone)
✓ "Adds caching layer for API responses"

From autoencoders/skills, CC-BY-4.0.

Signals

Stars
0
Forks
0
Open issues
0
Last commit (this folder)
Feb 6, 2026 (9 months ago)

From GitHub (fetched Oct 24, 2026).

Details

License
CC-BY-4.0
First seen
Oct 24, 2026
Last checked
Oct 24, 2026

More from autoencoders

Done for you

Rather not set it up yourself?

Chalk Labs scopes, builds and runs agents for your team: the task audit, the eval harness, the integrations and the weekly ops report. Fixed scope, priced before we start.

See how we build AI agents →Read the case studies

Chalk Labs is a two-founder AI and growth studio. We build AI agents, CRMs and MVPs for Web3 and AI companies, and have shipped 50+ product and token launches.

launches shipped
50+
launches shipped
media placements
500+
media placements
founders on every account
2
founders on every account

Press we've placed: Forbes · CoinDesk · Decrypt · Cointelegraph · The Block

Rahil Jain, Co-founder, Chalk Labs. Ex-Goldman Sachs engineer. You talk to the person who builds it.

Get implementation-verification running in your business

Tell us what you want to automate. A founder replies within one working day with a plan, not a pitch deck.

Goes to the Chalk Labs founders, not the newsletter. Privacy

Need help deploying implementation-verification?

CallGet help
Cite this page

implementation-verification skill. Agent Mart. https://agentmart.dev/skills/autoencoders-implementation-verification (last updated 2026-10-24)