AI Engineering Toolkit

A reusable, AI-first software engineering methodology for turning intent into software without asking AI to code first.

This toolkit helps teams use AI as an analyst, architect, reviewer, planner, implementation assistant, and documentation assistant while keeping humans responsible for framing, judgment, tradeoffs, validation, and final decisions.

Operating Model

The core flow is:

Intent -> Context -> Requirements -> Impact -> Design -> Delivery Plan -> Build / Review / Learn

The important rule is simple: do not start with code. Start by understanding the work, the system, the risks, and the decision space. Code generation becomes useful only after the target is clear enough to review.

Workflow

The methodology is organized into seven steps:

1. Intake Brief
2. Context Discovery
3. Requirements Definition
4. Domain and Impact Analysis
5. Architecture and Decision Design
6. Delivery Slicing
7. Build / Review / Learn

Each step produces reviewable artifacts that can be used by humans and AI agents. The artifacts are deliberately practical: briefs, requirements, impact notes, architecture decisions, threat models, and slice plans.

Usage Modes

Default to lightweight mode for bounded work. Escalate deliberately when risk, uncertainty, architecture impact, security/privacy concerns, migration, or cross-team coordination justify heavier artifacts.

Use full mode when the work has meaningful uncertainty, risk, or architectural impact:

• new product or new project
• major feature
• architecture change
• security-sensitive change
• legacy modernization initiative
• documentation or architecture extraction effort

Use lightweight mode when the work is bounded and low-risk:

• small feature
• bugfix
• refactoring
• local tooling
• technical cleanup

Lightweight mode still follows the same thinking path, but it compresses the artifacts so the process does not become heavier than the work.

Use Agent Task Routing before starting work when the next route is unclear or when multiple agent roles could apply.

Repository Structure

methodology/   Core workflow guidance and mode-specific flows.
templates/     Reusable briefs, specs, ADRs, threat models, and plans.
skills/        Agent skill definitions for repeatable AI-assisted tasks.
prompts/       Role prompts for planner, implementation, review, and documentation agents.
standards/     Engineering standards used by agents and humans.
adapters/      Tool-specific instructions for Codex, Claude, Continue, and similar tools.
examples/      Worked examples that demonstrate the methodology in practice.
tools/         Local automation helpers for repository operations.

This first version intentionally starts small. The repository should grow through reviewed slices, not by generating a complete process manual in one pass.

Start Here

For methodology navigation, start with:

• Methodology Index
• AI-First Engineering Methodology
• Shared Toolkit and Local Project Contract
• Agent Task Routing
• Model and Reasoning Effort Routing
• Lightweight Flow

For the first templates, use:

• Intake Brief Template
• Context Discovery Template
• BRD Template
• BRD-Light Template
• PRD Template
• Feature Spec Template
• Impact Analysis Template
• Architecture Brief Template
• Technical Design Template
• Threat Model Template
• Data Classification Template
• Vertical Slice Plan Template
• Review Checklist Template
• Release Notes Template
• ADR Template
• Agent-Readable Issue Template
• Task Contract Template
• Context Routing Template
• Implementation Continuity Note Template
• Methodology Improvement Note Template

For agent behavior in Codex, use:

• Adapters Index
• Codex Agent Rules

For reusable workflow skills, use:

• Intake Clarifier
• Context Discovery Agent
• BRD Generator
• PRD Generator
• Feature Spec Generator
• Requirement Analyst
• Domain Model Extractor
• Architecture Planner
• ADR Generator
• Legacy Impact Analyzer
• Threat Modeling
• Data Classification Assistant
• Vertical Slice Planner
• Code Reviewer
• Regression Risk Reviewer
• Release Notes Generator

For reusable role prompts, use:

• Master Planner Prompt
• Implementation Agent Prompt
• Review Agent Prompt
• Documentation Agent Prompt

For baseline standards, use:

• AI Agent Rules
• Documentation Standard
• Testing Standard
• Security Standard

For a worked example, see:

• Examples Index
• ReplayLab Intake Brief

For local automation helpers, see:

• Notion Progress Helper

For contribution guidance, see:

• Contributing
• Roadmap

Principles

• Human judgment stays in the loop.
• AI should clarify before it implements.
• Context is an input, not an afterthought.
• Requirements must include constraints, non-goals, and validation signals.
• Architecture decisions should be explicit enough to review later.
• Security, privacy, reliability, and maintainability are design concerns, not final checks.
• Delivery should be sliced vertically so learning starts early.
• Documentation should be created as a byproduct of the work, not a cleanup task.

Current Status

Initial repository scaffold, core methodology docs, artifact templates, reusable workflow skills, role prompts, baseline standards, and the first example guidance are in place.

The repository should continue growing through small example and adapter slices, with each new artifact reviewed against the methodology before it becomes a pattern.