Engineering with AI agents, not around them.

The developer who commits the code owns it — correctness, security, maintainability, performance, compliance, testing, and production impact. That ownership is the non-negotiable part. How much review effort it takes to discharge it is a judgment call, and that judgment scales with experience and with the risk of the change.

Don't carry unrelated tasks in the same session. Start a new session whenever the architectural concern changes — new feature, debugging a different system, repo switch.

Thin tools reduce hallucinations, improve predictability, simplify debugging, and reduce hidden side effects.

Before adopting a community plugin: review source, validate permissions, understand external API access, verify maintenance quality, evaluate security implications.

Maintain an internal catalog so the same vetting isn't redone in every team:

Frontend design skill. Component generation, accessibility checks, responsive layouts, design-system compliance. Enforces tokens, approved components, a11y standards.

Framework-specific skills (Laravel, Next.js, React, Terraform, Kubernetes). Pin framework versions, maintain internal guidance docs, review generated migrations carefully — outdated patterns and version mismatch are the main risks.

Code review skill. Focus on security risks, missing tests, dead code, code smells, performance anti-patterns, naming, architectural violations.

Every project includes: architecture overview, coding conventions, deployment flow, environment setup, business-domain glossary, API contracts, and testing strategy.

Recommended files: AI_CONTEXT.md, ARCHITECTURE.md, CONTRIBUTING.md.

Adapt these sections to your project: architecture summary, key domain rules, coding standards, forbidden patterns, deployment constraints, common pitfalls, testing expectations.

AI agents touch many files, explore alternative implementations, and create broad diffs. A worktree gives each session its own checkout on its own branch — sharing the same .git history but with a fully isolated working directory. That isolation is what makes running sessions in parallel (∥) safe: edits in one session never touch the files of another.

Claude Code creates worktrees for you — you don't drive git worktree by hand. Pass --worktree (or -w) and it creates an isolated worktree under .claude/worktrees/<name>/ on branch worktree-<name>, then starts the session inside it:

1. First time in a repo, run claude once and accept the workspace-trust prompt.
2. Start an isolated session: claude --worktree feature-auth (omit the name and Claude generates one like bright-running-fox).
3. Open another terminal and run claude --worktree bugfix-123 for parallel, non-colliding work. Or just ask Claude to "work in a worktree" mid-session.
4. On exit, Claude auto-removes the worktree if it's clean, or prompts you to keep/remove it when there are changes.

AI coding agents are most powerful when treated as a fleet, not a chat partner. Generation has unpredictable latency, and most coding work blocks on review rather than on the model. Sitting and watching a single session is the easiest way to leave throughput on the floor.

Pair this with Worktrees (08): each parallel task gets its own filesystem so the agents don't trip over each other.

There are two things to hold in your head. First, the path a single change travels — ten steps, grouped into four phases. Second, that you don't walk one task down that path at a time: you start several and let them overlap.

Because your steps are sparse, a single task leaves you idle while the agent generates and runs checks. So give each task its own worktree + session (see Worktrees (08)) and stagger them. When the agent is busy in one lane, you're reviewing or signing off in another — you become the scheduler, and the "needs-you" moments naturally fan out so you're rarely pulled two ways at once.

If production access is genuinely required: minimize permissions, require human approval, enable full audit logging, restrict destructive operations, isolate environments.

Never place production secrets, master API keys, or unrestricted cloud credentials directly into prompts or persistent agent memory.

The policy defines: approved tools, prohibited tools, data handling rules, security requirements, review requirements, production access rules, compliance obligations, and accountability expectations.

Special attention required for: customer data, credentials, healthcare data, financial information, legal documents, proprietary algorithms.

Maintain repository audit trails, commit attribution, AI-assisted PR tagging, infrastructure action logs, and credential usage tracking.

Required: tests, linting, typing, documentation, observability, security review, performance validation.

Track: delivery speed, defect rates, rollback frequency, review time, onboarding speed, developer satisfaction. If the numbers don't move, the workflow needs to change — not the policy.

A working prompt is institutional knowledge. So is a context file that's been iterated on. So is a worktree convention. Surface these so the next team gets the benefit.

Keep strengthening system design, debugging, performance analysis, security engineering, and code comprehension. AI is a multiplier on capability — it does not create it.