DevMethod

From idea to delivery with your AI coding agents.

Watch DevMethod build Lisière, then inspect a review — 4 min 03 s

▶ Watch the video — 4K, French narration · Subtitles and execution evidence · Download the working prototype

Existing Lisière film, extended with the new review interface. The original footage is retained, with an added narrated chapter showing real interface captures and a clearly fictional review example.

Concrete example: Lisière, a personal reading library. Start with an idea, compare three visual directions, approve a master screen, derive the other screen images, choose a suitable architecture, then build and verify the application.

| Step shown | Concrete result | | --- | --- | | Explore and frame | Add books, filter readings and track three statuses | | Design | Three alternatives → selected editorial master → add-book and completed-reading images | | Architecture | HTML/CSS/JavaScript, testable book rules and browser-local storage | | Plan, ready and implement | Working form, filters, status changes and saved books | | Review and verify | Corrected alert/focus behavior, 6 tests and real Chrome desktop/mobile journeys | | New review chapter | Find and filter findings, inspect evidence/corrections, distinguish coverage, inspect sources and export | | Integrate and handoff | Local prototype, references, evidence and resumption context |

The video uses illustrative Codex commands with real generated images and recorded application interactions. DevMethod guides the coding agent; image generation requires an available host tool. The visual workflow is included in npm 0.2.0. Follow the visual workflow.

DevMethod exposes fourteen devmethod-* workflow commands in the agent’s skill menu. The six procedure modules and existing project-foundation <stage> invocations remain supported.

A reusable workflow for taking a software project from exploration to delivery: decisions, UX, architecture, tickets, development, tests, review and handoff. Six focused skills support fourteen workflow stages, each ending with evidence, limitations and one suggested next command.

DevMethod 0.4.1. Complete review-to-report flow · 0.3 workflow changes. This release completes review generation and opening inside the agent, with an installed offline renderer. Review guidance now follows sensitive-data outputs, failure recovery and affected contracts beyond the diff; detection evaluation separates reproducible defects from measured reviewer results. Check the registry and GitHub release for publication evidence.

For developers and small teams using coding agents in new or existing repositories. Requires Node.js 22+ and npm; Git is required for context provenance. Application examples have separate framework/database prerequisites. DevMethod records scope, decisions and verification; it does not certify agent output, infer all dependencies, deploy applications or run an autonomous backlog. Installation and deterministic fixture results are separate from native host validation. See compatibility.

Start with missions and the tested source quick start, the tested from-zero Pocket Tasks project, then the complete Next.js/NestJS example. Advanced references: context and sizing, safe updates, resumption, optional stack profiles, bounded manual planning, troubleshooting, and release status and evidence.

Install in a project

Requires Node.js 22+ and npm. Install into a fresh staging directory first:

npx --yes [email protected] init --tool codex --dest ../foundation-staging

Choose codex, claude or cursor. If you omit --tool, an interactive terminal asks. For example:

npx --yes [email protected] init --tool claude --dest ../foundation-staging --dry-run

Remove --dry-run to write. Select a subset with --modules decision-architecture,scoped-delivery; project-foundation is always included. Without --modules, all six modules are installed. The installer refuses divergent files and duplicate skills across host directories. It never edits AGENTS.md, CLAUDE.md or your package.json. Review the staging output, then merge only what the project needs.

The installer has no runtime dependencies and makes no network requests after npm obtains the package. To pin the final version, use npx --yes [email protected] init .... To pin a reviewed repository commit instead, use: npx --yes --package=github:montassarkhalloufi/DevMethod#<commit-sha> devmethod init ....

Complete PROJECT_PROFILE.md with your real stack, commands, scope, deployment permissions and data requirements. Merge AGENTS.foundation.md into the project's existing instructions only after review. Claude Code reads CLAUDE.md: preserve its current content and, if the project has AGENTS.md, optionally add @AGENTS.md to import it. Keep existing accepted architecture decisions authoritative.

The installer includes DEVMETHOD-LICENSE so it preserves your application's LICENSE. Retain that MIT notice with redistributed copies. Repository-level release documents and the CLI are not copied into your application.

Installation copies the reusable method and blank templates, not another project's context. Preserve filled profiles, decisions, tickets and instruction files separately. Manifest hashes describe the initial installation; local template customization is expected to change them. To install elsewhere, run the CLI again.

Verify the source checkout

From a reviewed source checkout:

npm ci
npm test
npm run check:docs
npm pack --dry-run
node dist/cli.js init --tool codex --dest ../candidate-staging
node dist/cli.js doctor --dest ../candidate-staging --json
node dist/cli.js update-preview --dest ../candidate-staging --json

The package includes advanced docs and fictional examples. init copies only the skills and adoption templates, preserving the application. Read the package docs from its checkout or extracted tarball. The core CLI has no runtime dependencies; example applications install their own pinned dependencies separately.

Inspect an adopted installation

From a reviewed source checkout, inspect an installed project without changing it:

node dist/cli.js doctor --dest /path/to/project --json

Doctor reports missing files, changes from the initial manifest and duplicate host copies. Customized profiles and skills produce warnings; they are preserved. It does not execute an agent or certify application quality. See diagnostic codes and exit statuses.

Choose the amount of process

The stages below are available entry points, not fourteen mandatory conversations.

| Path | Typical work | Expected process | |---|---|---| | Quick | Clear bug fix inside existing contracts | Inline readiness, implementation, focused verification and review | | Standard | Feature spanning components or sessions | Ready slice, relevant contracts, checks and resumable evidence | | Major | New product decisions or consequential architecture changes | Resolve decisions, split into slices, verify integration |

Risk and repository policy override apparent size. Reuse accepted UI, architecture and project context; only fill actual gaps. See work sizing and starter exercises.

Run the workflow

In Codex: select $devmethod-status or $devmethod-review TASK-1.

In Claude Code or Cursor: select /devmethod-status or /devmethod-review TASK-1.

After installation, these commands run the workflow in your agent without npx. For example, $devmethod-review inspects actual changes, runs relevant checks and reports findings; it does not merely open the viewer. Existing project-foundation <stage> syntax remains valid. Partial module installs expose only stages supported by the selected modules. See command discovery and updates.

Select an action below and add its target. These are prompts to the skill, not shell commands or standalone /verify commands. They do not create a background autonomous loop.

| Action | Result | |---|---| | devmethod-explore | Dated research on existing solutions, uncertainty and next direction | | devmethod-frame | Product scope, exclusions and success measures | | devmethod-design | Visual directions, selected mockups and UX criteria; image tooling depends on the host | | devmethod-architecture | Conversation and explicit choice/delegation before dependent detail | | devmethod-plan | Useful scope discussion, conditional milestones and near-term tickets | | devmethod-ready TASK-1 | Readiness assessment before implementation | | devmethod-implement TASK-1 | Scoped code, tests and corrections | | devmethod-review TASK-1 | Evidence-backed inspection, structured findings, checks, sources and report | | devmethod-verify TASK-1 | Executed checks and remaining gates | | devmethod-integrate TASK-1 | Delivery under existing permissions | | devmethod-correct-course | Resolve changed scope or blocked decisions | | devmethod-next | Select the next authorized slice | | devmethod-status | Current evidenced implementation status | | devmethod-handoff | Resumable checkpoint |

See research, decision dialogue and mission migration. See the full command contract. A failed check returns to correction; a blocked gate leads to handoff or replanning. Tests, code review and native permissions remain necessary.

More recorded examples

Detailed recorded Lisière chain · Short Clair demo · Run Clair. Clair is a separate from-zero example. The featured film retains the Lisière story and adds an explicitly separate fictional review example.

Review your changes and open the report

In your coding agent, ask:

$devmethod-review the current changes, then open the report

In Claude Code or Cursor, use /devmethod-review with the same request. The agent inspects the actual changes, runs relevant checks, records evidence-backed findings and justified impact, then generates the Markdown and interactive HTML reports from the real review JSON and opens the HTML. You do not need to launch npx, a terminal command or a server. The renderer is installed with scoped-delivery and runs locally with Node.js 22+.

For a small review without a requested report, the result can stay in the conversation. On a headless machine or if browser opening fails, the generated artifacts are preserved and linked with the opening limitation. Existing reports are never overwritten. See review workflow and report delivery.

The screenshots below use clearly fictional data to illustrate the interface; your review uses actual project results. The separate terminal viewer remains available for manual use and demos, as described in the review guide.

Follow the review walkthrough · JSON, Markdown and HTML example · Review chapter provenance

The example contains two fictional findings and three separate checks. Severity, confidence and resolution remain distinct. Sources show whether they were actually consulted. The same structured record produces the UI and reports; tickets reference stable finding IDs.

Visual design and architecture

DevMethod connects art-direction selection, an approved master screen, derived image mockups and browser fidelity checks with technology and architecture decisions. Follow the visual workflow guide and recorded Lisière pilot. These capabilities are included in npm 0.2.0; npm 0.1.0 predates them. See the 0.2.0 release record for publication status.

Included modules

project-foundation, decision-architecture, design-to-code, react-feature-engineering, reliable-ai-integration, scoped-delivery.

Use the modules your project needs. Adapt the workflow to your stack, architecture and delivery process.

Where DevMethod can improve

The target is a compact engineering workflow for verifiable changes in existing repositories. BMad already documents adaptive planning, existing-codebase workflows and broader automation; DevMethod has not demonstrated parity or superiority. Read the sourced comparison, prioritized roadmap, and evaluation protocol. We aim to measure correct outcomes, honest evidence, context cost and reliable resumption under matched conditions.

Demo material

The workflow illustration above is kept in the repository as an SVG so it remains reviewable and usable in dark mode. Try the runnable bug-fix exercise, which includes an intentionally failing baseline and an explicit task. It is a fixture, not a recorded model success. A real demonstration should preserve the observed failures, changes and checks; use the native smoke protocol to assess the host workflow.

Verify and contribute

npm ci
npm test
npm pack --dry-run

Read CONTRIBUTING.md, COMPATIBILITY.md, and the release checklist. Licensed under MIT.

A bounded native Codex pilot now records actual fixture execution and independent review. It covers one matched B1 triple and two DevMethod probes, not a completed comparative campaign or general autonomous dispatch.