agentleFS
5uck1ess5uck1ess/devkit/CLAUDE.md

devkit

CLAUDE.md4 starsChanged 4 months agoMITView on GitHub

Navigation map for Claude Code working in this repo. Anchor-style, not narrative — keep it short. pr-ready's doc-check targets this file, so stale entries get caught at PR time. devkit is a Claude Code plugin: deterministic YAML workflow engine, dispatcher and capability skills, enforcement hooks, multi-agent consensus.

The file

We split this CLAUDE.md into the rules it gives an agent

5 rules. About 0 are common, 2 are distinctive, and 3 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈2

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 3

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  • could be automatic: a setting could enforce it
  1. Distinctive:

    Never push directly to main.

    line 53
  2. Distinctive:

    Never amend commits — create new ones, even after pre-commit hook failures.

    line 54
  3. Very specific:

    Never skip hooks (--no-verify, --no-gpg-sign) without explicit user consent.

    line 55
  4. Very specific:

    Commit message style: check recent git log before writing one.

    line 56
  5. Very specific:

    No direct edits to ~/Documents/LocalDev/claude-shared/ — the OneDrive copy is primary.

    line 59

≈ “Common” is an estimate: at least 1 in 5 of the 26,980 CLAUDE.md files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
CLAUDE.md

CLAUDE.md

Navigation map for Claude Code working in this repo. Anchor-style, not narrative — keep it short. pr-ready's doc-check targets this file, so stale entries get caught at PR time.

devkit is a Claude Code plugin: deterministic YAML workflow engine, dispatcher and capability skills, enforcement hooks, multi-agent consensus.

Layout

PathWhatGrep here for
skills/39 SKILL.md skills (engine dispatchers + capability tools)Skill descriptions; what each skill triggers (workflow or direct exec)
skills/_principles.ymlShared cross-cutting principle configRules applied to every skill
skills/creating-workflows/Workflow YAML schema referenceStep types, parallel:/branch:/loop:/expect: semantics
workflows/22 YAML workflow definitionsWhat each skill actually runs
src/engine/engine.goGo workflow executorHow parallel: [ids] fans out (runParallel), branch eval, loop gates, end:
src/engine/workflow.goWorkflow struct + YAML parsing + validationStep field definitions; ParallelChildren/NextIndex (shared sequential walk)
src/cmd/guard.goHook gatekeeperWhat Bash/Edit/etc. is allowed per step type + enforce level
src/cmd/workflow.godevkit workflow CLI commandWorkflow invocation entry point
src/cmd/mcp.godevkit mcp CLI commandMCP server bootstrap
src/cmd/probe_local.godevkit probe-local CLI commandLocal-inference endpoint health probe (human + --json)
src/mcp/tools.goMCP tool schemasdevkit_start, devkit_advance, devkit_list, devkit_status contracts
src/mcp/server.goMCP server implementationTool dispatching
src/mcp/principles.goPrinciple injectionHow _principles.yml reaches workflows
src/runners/runner.goModel tier interfaceThe smart/general/fast contract
src/runners/{claude,codex,gemini}.goCloud tier implementationsHow each external CLI is called
src/runners/local.goLocal runner (Ollama/llama-server/vLLM)OpenAI-compatible HTTP client; opt-in via DEVKIT_LOCAL_ENABLED=1
src/lib/state.go + state_json.goWorkflow state persistenceRunning-state schema, step outputs
src/lib/state_lock_{unix,windows}.goCross-platform file lockingOS-specific state lock
src/lib/git.goGit helpersDiff collection, branch checks
src/lib/report.goFinal-report formattingWorkflow output rendering
hooks/hooks.jsonPreToolUse/PostToolUse/SubagentStop/Stop wiringWhich shell script runs for which event
hooks/*.shIndividual hook scriptssafety-check, audit-trail, pr-gate, stop-gate, lang-review, etc.
agents/*.md6 subagent definitionsdocumenter, improver, researcher, reviewer, security-auditor, test-writer
mcpb/MCPB bundle (launcher, manifest.json, server)Packaged distribution artifact
bin/devkitUser-facing CLI wrapperShells out to the devkit-engine Go binary
resources/rules/Language coding rules (common + go/python/rust/typescript/shell/java/kotlin/swift/csharp)Installed via the setup-rules skill
.claude-plugin/plugin.jsonPlugin manifestName, version, mcpServers pointer
src/MakefileBuild + test + version syncmake build, make test, make check, make sync-version
commands/references/3 reference files pulled in by skills (debug-checklists.md, domain-probes.md, stub-patterns.md)Shared checklist/probe/stub content; write new work as skills

Architectural invariants

  • Workflows are deterministic. The engine controls step sequencing, loops, branches, and gates — not the model. YAML is parsed once, the graph is fixed, steps run with state persistence and hook enforcement.
  • Skills come in two flavors. Engine-shim skills (most) are thin dispatchers that call devkit_start then loop on devkit_advance, delegating to the workflow engine. Capability skills (e.g., skills/scrape/) are runtime-interpreted prompt templates where the model is the executor — it picks a backend from what's installed, generates shell/script via heredoc, judges output, falls through on failure. Use the capability form when work needs on-the-spot adaptation that pre-compiled YAML can't express (anti-bot arms races, heterogeneous backend outputs, content-judgment branching).
  • Parallel step pattern. Steps listed in another step's parallel: [ids] are skipped during the sequential walk (Workflow.NextIndex in src/engine/workflow.go, used by both the CLI engine and the MCP server) and run only inside their dispatcher — runParallel in the CLI, per-child outputs on devkit_advance over MCP. Never expect a step that appears in a parallel list to also execute in its sequential position.
  • Enforce levels gate hook permissions. enforce: soft lets gather/setup steps run git diff and other shell work during dispatch; enforce: hard blocks them. The gatekeeper logic lives in src/cmd/guard.go; see guard_test.go for the allow/deny matrix.
  • Engine binary is separate from the CLI wrapper. bin/devkit is the committed shell wrapper; it execs devkit-engine (compiled Go, gitignored). The wrapper handles install/version checks; the engine handles workflow execution.
  • Skills are the future; commands/ is legacy. PR #77 migrated commands to skills. Both auto-discover, but skills support paths, disable-model-invocation, and supporting files.

Conventions

  • State assumptions before implementing. If multiple interpretations exist, present them — don't pick silently.
  • Never push directly to main. Always PR. Direct push bypasses the version-bump and release pipeline.
  • Never amend commits — create new ones, even after pre-commit hook failures.
  • Never skip hooks (--no-verify, --no-gpg-sign) without explicit user consent.
  • Commit message style: check recent git log before writing one. Repo uses conventional-commit prefixes (docs:, fix:, feat:, refactor:, chore:).
  • Version bumps happen automatically on PR merge — don't hand-edit .claude-plugin/plugin.json version.
  • CHANGELOG.md is managed by the release pipeline, not by pr-ready's doc-check or manual edits.
  • No direct edits to ~/Documents/LocalDev/claude-shared/ — the OneDrive copy is primary; the local path is a GitHub backup.

Fixing this file

If a row above is wrong or a lookup keeps failing, fix it in the same PR that changed the underlying code — pr-ready's doc-check targets CLAUDE.md. If you find a recurring exploration query that isn't covered, add a one-liner anchor to the layout table. Keep it short; this file exists to save tokens, not to explain devkit.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.