Forward implementation first: make coding agents do real work before bookkeeping

Who it's for

• Developers using coding agents such as Claude Code or Codex: your agent is often slowed down by its own "paperwork" — writing hashes, adding locks, generating receipts, adding authentication markers or progress metadata for every change, instead of finishing the real implementation work first. This skill uses behavioral constraints to make the agent prioritize substantive work.
• Users installing at the personal or project level; the official documentation supports Claude Code (~/.claude/skills/forward-implementation-first/), Codex (~/.codex/skills/forward-implementation-first/), and the shared convention directory ~/.agents/skills/forward-implementation-first/.
• When it's not a fit: if your agent is itself required by its process to produce these records (e.g., the records are a product requirement), the skill's core rules will instruct it to skip such operations, and they will only run when you explicitly request them.
• Not covered by evidence: agent version requirements, supported operating systems, compatibility with other agents, and the types of text or the documentation/code scope this skill handles — all unknown; do not assume them.

First attempt in 3 minutes

Prerequisites: git access to GitHub from your machine; the target agent (e.g., Claude Code) is installed. Side-effect warning: the install script copies SKILL.md into the agent's skills directory and writes files in your user or project directory; for a first attempt, start with a low-risk task.

1. Install location: install to the user-level directory first. The official primary path command:

git clone https://github.com/Vuk97/forward-implementation-first
cd forward-implementation-first
./install.sh

The script copies the skill to ~/.claude/skills/forward-implementation-first/ (Claude Code) and the corresponding directories for other agents.

1. Restart the agent. The official documentation is explicit: running sessions do not reload skills; a restart is required for them to take effect — this is the key prerequisite for observing any effect.

2. Trigger a low-risk task: ask the agent to do a small analysis or inspection task (e.g., "review this code and point out issues", without modifying files). When the skill is active, the agent classifies every action before performing it into one of three categories: semantic implementation, focused verification, or administrative bookkeeping — and only performs the first two, skipping the third (unless you request it or it is part of the product).

3. Success signal: the agent's execution directly advances analysis and implementation steps, no longer inserting extra "paperwork" actions such as generating hashes, receipts, authentication markers, or progress metadata; and it can state which category each action belongs to. This is the direct manifestation of the officially described core workflow. Output format or inspection process details beyond this are not covered by the evidence.

Alternative: to make it effective only in a single project, the official documentation says you can copy the directory into the project's .claude/skills/ or .agents/skills/.

Use cases

Case 1: Suppressing verbose process records. Scenario: your agent spends many steps generating locks and receipts before fixing a bug. Ask the agent: "Fix issue X directly, don't generate extra progress metadata." The skill's classification workflow categorizes the fix as semantic implementation and prioritizes it, while categorizing record generation as administrative bookkeeping and skipping it. Expected result: a more direct fix path and noticeably less process output.

Case 2: Code review tasks. Scenario: ask the agent to check a module for issues ("review the error handling in file.py"). With the skill active, the agent categorizes the review as focused verification and performs it directly, without attaching authentication markers or other formalities. Expected result: direct analysis results. Output format or additional inspection processes are not covered by the evidence; rely on the agent's actual reply.

Boundaries of use

• Files and side effects: installation itself writes files (the skills directory); after restarting the agent, the skill influences agent behavior through behavioral constraints. Whether the skill directly reads or writes user files, executes commands, or accesses the network — none of this is covered by the evidence and cannot be confirmed; set your own confirmation points when using it.
• Confirmation points: when the task itself requires producing record-type artifacts (e.g., a project requires progress documentation), the agent will skip it per the rules and needs your explicit request; this is an exception stated in the official documentation — spell it out in your instructions.
• Runtime environment: installation depends on git clone and running ./install.sh; shell/system requirements are not stated by the official documentation.
• Client prerequisites: the officially listed installation targets are Claude Code, Codex, and the shared ~/.agents/skills/ convention directory; support for other clients is unknown.
• Officially stated limitations: skills do not take effect until restart; project-level installation requires copying into .claude/skills/ or .agents/skills/.
• Unconfirmed information: supported text/code language scope, configuration options, and uninstallation method have no official documentation.