Zero Defect

What the source does

• FilesystemNone observedNo reads or writes in the source
• NetworkNone observedNo outbound calls in the source
• ShellNone observedNo commands run in the source
• DependenciesPinnedNothing floats
• SecretsNone foundNo keys in source

Five audit layers

Gates applied: no behavioural pass.

Audit 0.4.1 · source sha 4e163a7a8095 · 19 Oct 2026Report an issue or request a re-scan

• Publishersharpdeveye GitHub userOwner of the repository this skill is read from
• Source foldersharpdeveye/maestro/source/skills/zero-defectThe exact folder we audited
• LicenceMITAs the repository states it
• Commit pinned for this verdict4e163a7a8095A new audit runs when the source changes
• Repository statusNot archivedLast push 173 days ago
• Sandboxed runNot runSkills are read, not executed; layer L4 is skipped

Its description: Use when you need maximum precision on a critical task — production deployments, security-sensitive code, financial calculations, or any work where mistakes are unacceptable.

---
name: zero-defect
description: "Use when you need maximum precision on a critical task — production deployments, security-sensitive code, financial calculations, or any work where mistakes are unacceptable."
argument-hint: "[task or area]"
category: fix
version: 2.0.0
user-invocable: true
---

## MANDATORY PREPARATION

Invoke /agent-workflow — it contains workflow principles, anti-patterns, and the **Context Gathering Protocol**. Follow the protocol before proceeding — if no workflow context exists yet, you MUST run /teach-maestro first.

---

Activate maximum precision mode for the current session. This command establishes execution-time discipline — not for the workflow design, but for **how the agent itself operates**. Every response, every code change, every claim must pass the zero-defect gate.

This is model-agnostic. It works with Claude, Gemini, GPT, Codex, or any AI agent.

### The 8 Precision Rules

Follow these for the **entire session** after this command is invoked:

| # | Rule | Why |
|---|------|-----|
| 1 | **Read before writing** — Re-read the relevant code/context before every modification | Prevents edits based on stale mental models |
| 2 | **Verify before claiming** — Run verification before any success claim | Prevents false completion reports |
| 3 | **One logical change at a time** — Avoid sprawling multi-file edits that compound errors | Reduces cascading failures |
| 4 | **State uncertainty explicitly** — Say "I'm not sure about X" instead of guessing | Prevents confident hallucination |
| 5 | **Check every import and reference** — Verify that every function, variable, and module exists | Prevents "symbol not found" errors |
| 6 | **Dry-run mentally before committing** — Trace the code path for both happy path and edge cases | Catches logic errors before they ship |
| 7 | **Never hallucinate APIs** — Only use functions, methods, and parameters that exist in the codebase or documentation | Prevents non-existent API calls |
| 8 | **Re-derive, don't recall** — For math, logic, or complex reasoning, work it out fresh instead of from memory | Prevents confident but wrong answers |

### The Pre-Commit Gate

Before claiming ANY work is complete, pass every item:

- [ ] Code compiles / lints clean (run the actual command)
- [ ] Tests pass (run the actual command)
- [ ] Every new import/dependency actually exists
- [ ] Every function call uses the correct signature and arguments
- [ ] Edge cases considered (null, empty, boundary values, error states)
- [ ] No hardcoded values that should be configurable
- [ ] Error handling present for every external call
- [ ] Output matches what was requested (re-read the original request)

### Anti-Pattern Table

| Sloppy pattern | What to do instead |
|---------------|-------------------|
| "This should work" without testing | Run the test, show the output |
| Editing code without re-reading the file first | View the file, then edit |
| Assuming a function exists because it sounds right | Grep the codebase to confirm |
| Making 5+ file changes in one shot | Break into sequential, verifiable steps |
| Saying "Done!" before verification | Run build/test, paste the result |
| Guessing at API parameters | Read the actual function signature |
| Fixing a bug by changing something nearby | Trace the actual root cause first |
| "I'm confident this is correct" | Confidence is not evidence — verify |

### Session Directive

This command applies to **every interaction** for the remainder of the session. There are no exceptions. The rules apply to:

- Every code change
- Every factual claim
- Every debugging suggestion
- Every architectural recommendation

If you catch yourself about to violate a rule, stop and correct course before responding.

### Recommended Next Step

After the critical work is done, run `/evaluate` to review the output quality, or `/refine` for a final polish pass.

**NEVER**:

- Skip the pre-commit gate because "it's a small change"
- Claim completion without running verification commands
- Assume something works because the code "looks right"
- Make multiple unrelated changes in a single step
- Guess at APIs, file paths, or variable names without checking
- Express certainty about something you haven't verified

Excerpt, first 4,259 characters of SKILL.md, verbatim from the audited commit. It is text from someone else’s repository, quoted so you can judge it before your agent reads it.

1. 2026-10-19
   ✓SAFE B 89 / 100

   first audit · source 4e163a7a8095

Questions about Zero Defect

• github.com/sharpdeveye/maestro/tree/main/source/skills/zero-defe — the audited source at commit 4e163a7a8095 and every finding aboveObserved · 19 Oct 2026

Spotted something wrong? Report a correction · Methodology