idev

idev — Token-Optimized Development Workflow Plugin

A Claude Code plugin packaging 27 skills, 9 agents, 10 commands, and a session-startup hook built around generic-first design: skill logic is universal, project knowledge lives in per-project caches that every skill regenerates by scanning the project it lands in. The scanners are strongest on .NET/React-style projects; other stacks fall back to generic heuristics.

Install & Setup

From GitHub (inside Claude Code):

/plugin marketplace add TheophilusChinomona/idev
/plugin install idev@idev

Or test a local checkout:

claude --plugin-dir /path/to/idev

Then, inside each project, scaffold the per-project state:

/idev:idev-init

/idev:idev-init is the one required setup step per project: it creates .claude/idev/ (caches, task journal, lessons file, config templates) and offers to append the operating-guide snippet (templates/claude-md-snippet.md) to the project's CLAUDE.md — the always-loaded routing layer that tells Claude the cache-first context rules, the skill workflow chain, the agent delegation map, and your per-project policies. The SessionStart hook stays completely silent in projects where .claude/idev/ doesn't exist, so nothing happens until you run it.

How it works

Two ideas drive everything:

• Plugin = logic, project = state. The plugin install directory is read-only logic: skills, agents, scripts. Everything mutable lives in <project>/.claude/idev/ — indexes, pattern caches, journal, lessons, session snapshots. Skills regenerate that state by scanning whatever project they land in, which is what makes the same plugin work across different codebases.
• Skills load themselves; you mostly just work. Each skill carries a description telling Claude when to use it ("after creating an API endpoint…", "when resuming a session…"). You don't invoke skills by name — you ask for normal dev work and the relevant skill's procedure kicks in. The only always-on piece is the SessionStart hook, which injects last-session context, pending journal tasks, and the smart-context index pointer at the start of every session (and stays silent in projects you haven't initialized).

How to use

1. First session in a project

Run /idev:idev-init once. It creates .claude/idev/ with the journal, lessons file, rules file, and config templates, offers to append the operating-guide snippet to your CLAUDE.md (how Claude should drive the plugin in this project, plus your tunable policies), and generates the smart-context index (scanner.py detects your stack, features, and conventions). From then on, every session starts with that context injected automatically.

2. Day-to-day development

Just describe tasks normally. The skills slot into four phases of the work:

Finding things — instead of reading whole files, Claude consults the caches first: the smart-context index for "which files implement feature X", the file index for fast path lookup, the project map (grepped, never loaded whole) for structure, and the Function Index inside the pattern caches for "where is function Y" without reading the file.

Writing code — architecture-scanner works out which layer a file belongs to; backend-patterns / frontend-patterns scan your codebase once, cache its conventions (file layout, naming, error handling, DI, API client patterns), and make new code follow your style rather than generic style. coding-standards adds security checks when code touches user input, auth, secrets, or queries.

Verifying — after creating files, post-creation-verify checks the wiring (registrations, route tables, DI containers — the stuff that compiles but doesn't run); build-check builds once per logical change set; api-contract-validation cross-checks frontend calls against backend endpoints (paths, methods, DTO shapes) and can emit contract docs; feature-completeness traces a feature end-to-end (UI → service → endpoint → DB) to catch dangling links; self-review runs a final invariant check against your project's cached patterns; test-map knows which tests cover which files so only the relevant ones run; browser-test (+ the browser-tester agent, /idev:browser-test) verifies UI flows with real Playwright runs — every verification script is saved to .claude/idev/browser-tests/scripts/ so the project accumulates an E2E suite as a side effect of normal work.

Remembering — task-journal tracks in-flight work across sessions; session-resume snapshots state so "pick up where we left off" works; lessons-learned logs mistakes-with-fixes so they aren't repeated. The SessionStart hook surfaces all three next time.

Useful things to say: