idev-codex

Senior backend architect for system design decisions — service decomposition, database schema design, API contract governance, migration strategy, reliability and observability patterns. Use when designing a new backend system or service, choosing between monolith/microservices, designing schemas or APIs, or planning a data migration. Advisory only — produces specifications, does not write code.

Branch synchronization agent — merges the team base branch into the current feature branch before a PR, resolves merge conflicts with three-way evidence and intent analysis, verifies the merge with a build and targeted tests, and reports what was merged and how each conflict was resolved. Use when preparing a branch for a PR, when a PR has conflicts with its target, or when asked to sync/update a feature branch with developer/main.

Browser testing agent — verifies web features and user flows end-to-end by writing and running re-runnable Playwright scripts, capturing screenshot/console/network evidence, and producing structured test reports. Use when a UI change needs real-browser verification, a user flow needs smoke testing, a UI bug needs reproduction, or the user asks to test the site in a browser and report results.

Expert code reviewer providing constructive, prioritized feedback on correctness, security, maintainability, performance, and test coverage — not style preferences. Use when reviewing a diff, branch, or PR for general quality. For a security-only deep audit, use the security-reviewer agent instead.

Expert frontend developer for building and improving web UI — components, state management, responsive layouts, accessibility, and Core Web Vitals performance. Use when implementing UI features or component libraries, fixing layout/responsiveness issues, improving accessibility compliance, or optimizing bundle size and page performance.

"Codebase onboarding specialist — builds fast, accurate mental models of unfamiliar repositories by reading source, tracing execution paths, and stating only facts grounded in inspected code. Use when onboarding into a new codebase, asking "where should I start", "what owns this behavior", or "how does a request flow through this system". Strictly read-only and descriptive — no reviews, refactors, or recommendations."

Expert planning specialist for complex features and refactoring. Use PROACTIVELY when users request feature implementation, architectural changes, or complex refactoring. Automatically activated for planning tasks.

Dead code cleanup and consolidation specialist. Use PROACTIVELY for removing unused code, duplicates, and refactoring. Runs analysis tools (knip, depcheck, ts-prune) to identify dead code and safely removes it.

Deep security audit specialist for comprehensive vulnerability analysis. Use for detailed security audits, penetration testing preparation, and in-depth OWASP compliance reviews. For always-on security checks, the coding-standards skill handles this automatically.

Verifies frontend API calls match backend endpoints (URL paths, HTTP methods, request/response types). Use after creating or modifying API endpoints, service functions, or DTOs, or when asked to validate API alignment, check FE-BE contracts, or generate API contract docs.

Detects which architectural layer (frontend or backend) a file or task belongs to and routes to the matching pattern skill. Use when a task spans frontend and backend, or when determining which layer a file belongs to.

Caution protocol for destructive operations. Use before deleting files, dropping database objects, removing exports/public APIs, or running irreversible commands.

Instinct-based learning system that observes sessions via hooks and evolves patterns into skills/commands/agents. Use when the user asks about learned instincts, wants to analyze session patterns, sets up auto-learning or observation hooks, or runs $idev:instinct-status, $idev:instinct-export, $idev:instinct-import, or $idev:evolve.

Scans the codebase to auto-detect backend code conventions (controllers, services, entities, DTOs, DI registration) and caches them. Use when creating or modifying backend code so new files follow existing patterns exactly.

Syncs the current feature branch with the team base branch (merge base into feature) before creating a PR, resolving merge conflicts safely with build/test verification. Use when preparing a branch for a PR, when asked to sync with or merge in the base/developer branch, when a PR shows conflicts, or before pushing a long-lived feature branch.

Code-as-action browser testing: verify UI changes and user flows by writing re-runnable Playwright scripts, capturing screenshots/console/network evidence, and producing test reports. Use when verifying a web feature in a real browser, reproducing a UI bug, smoke-testing a flow after changes, or asked to test the site / run browser tests.

Auto-detects the project's build system and runs compile/type-check after file changes, auto-fixing straightforward errors (max 3 attempts). Use after completing a multi-file feature or when asked to build or check compilation.

Keeps idev skill caches fresh after source files are created, deleted, or renamed. Use after structural file changes or when the user says refresh caches.

Turn a codebase into an onboarding playlist — Claude-authored analysis docs plus NotebookLM explainer videos (one overview + one per subsystem). Use when asked to explain a codebase, onboard onto a repo, make explainer/walkthrough videos of the code, or 'help me understand how this whole thing works'.

Security-focused code review standards. Use when reviewing code for security issues, or when writing code that handles user input, authentication, secrets, file uploads, or database queries.

Run the skill quality benchmark — static scorecard for every skill in this plugin (or a given plugin directory), with category classification and improvement recommendations.

Run code-as-action browser tests — verify a web feature or user flow with a real Playwright run and get a structured report with screenshot/console evidence.

Cluster related instincts and evolve them into skills, commands, or agents

Turn this codebase into an onboarding playlist — analysis docs plus NotebookLM explainer videos (overview + per-subsystem), with a doc-review checkpoint before any video is generated.

Manage idev's optional hooks without editing settings — show status, enable/disable the auto-learning observer and compact suggester, and install the team git commit hooks.

Export learned instincts to a shareable file for teammates or other machines

Import instincts from a teammate's export file or a URL

Show all learned instincts with their confidence levels, grouped by domain

Review a pull request with the code-reviewer agent — fetches the PR diff (Azure DevOps or GitHub), reviews against project conventions, and returns prioritized findings.

Sync the current feature branch with the team base branch before a PR — merge base in, resolve conflicts with evidence, verify with build/tests, and report.

Reconcile this project's .codex/idev/ state with the currently installed plugin version — add missing directories and config keys, refresh the AGENTS.md snippet, and update stale idev git hooks, without touching caches or user content.

Team commit-message conventions. Use when writing a commit message, committing or amending changes, or when asked about the project's commit format. Reads the per-project style from .codex/idev/commit-style.md.

Session environment sanity check — verifies cwd is the repo root, git auth is live, DB env vars are present, and reports active sandbox constraints. Use when starting a session, when credentials may have expired, or when the environment feels stale.

Traces a feature end-to-end (UI, hook, service, API, controller, database) to verify every link is wired. Use after completing a multi-layer feature or when asked whether a feature is fully connected.

Compact feature-to-file index mapping feature names to exact file paths. Use when the user mentions a feature and exact file paths are needed, or to refresh the index after files change.

Scans the codebase to auto-detect frontend conventions (pages, containers, components, hooks, services) and caches them. Use when creating or modifying frontend code so new files follow existing patterns exactly.

Reads only the needed function from a large file (300+ lines) instead of the entire file, using grep/index line numbers. Use when one function is needed from a big file.

Scaffolds the per-project .codex/idev/ state directory (caches, journal, lessons, config templates) for the idev plugin. Use when starting idev in a new project, when the SessionStart hook reports the state directory is missing, or when the user runs $idev:idev-init or asks to 'set up idev'.

Lightweight dependency graph of which files import which, for path-based-import languages (TS/JS, Python, Go). Use before modifying a shared type, interface, service, or export to find dependent files that might break.

Persistent memory of past mistakes, fixes, and gotchas with prevention steps. Use when starting a new feature (read prevention steps) or after fixing any bug or discovering non-obvious behavior (append a lesson).