Skip to content

AI-Assisted Development
What How AI tooling is used across the lifecycle, responsibly and as a first-class practice.
Owner Engineering, with standards reinforced by Tech Leads and the Manager.
Triggers Every phase. AI is a layer across the lifecycle, not a separate stage.

Summary

AI-assisted development is a standard, expected part of how we work, not an exception. It spans planning, coding, review, and documentation. The guiding principle is simple: AI accelerates the work, but the engineer remains accountable for everything that ships. Plans are made before code, AI output is reviewed like any other change, and each repository keeps machine-readable living documentation that AI tools can read and help maintain.

Full detail

Principles

  1. The author is accountable. AI-generated code is the author's code. It goes through the same tests, static-analysis gate, and review as anything else. "The AI wrote it" is never an explanation for a defect.
  2. Plan before code. For non-trivial work, produce a plan or spec first (spec-driven development, or a plan-mode pass) and confirm the approach before generating large amounts of code. This keeps AI output aligned with the actual requirement and the existing design.
  3. Review applies equally. AI-assisted changes follow the normal code review flow. Reviewers do not relax scrutiny because a tool produced the diff; if anything, they check for plausible-looking but subtly wrong output.
  4. Context over guessing. Point AI tools at the real codebase, the ticket, and the in-repo docs rather than letting them invent structure. The living docs below exist partly for this.

AI across the phases

Phase Useful AI assistance
Grooming / Planning Drafting acceptance criteria, surfacing edge cases and risks to clarify.
Development Spec-driven scaffolding, plan-mode before implementation, test generation, refactoring.
Code review A first-pass AI review to catch obvious issues before human review, never replacing it.
Debugging Summarizing logs and traces, hypothesizing root causes (verified against evidence).
Documentation Keeping in-repo Markdown and diagrams current as code changes.

Living, AI-readable docs in every repo

Each repository keeps its documentation as Markdown and Mermaid diagrams committed alongside the code (see Documentation Standards). This format is chosen deliberately: it is readable by humans in review and by AI tools that read the repo, so AI can both consume accurate context and help keep the docs updated when code changes. When a change alters behavior, the docs change in the same pull request.

flowchart LR
    A[Ticket + requirement] --> B[AI helps draft plan / spec]
    B --> C[Engineer confirms approach]
    C --> D[AI-assisted implementation + tests]
    D --> E[Static analysis gate]
    E --> F[AI first-pass review]
    F --> G[Human code review]
    G --> H[Merge]
    H --> I[AI helps update in-repo docs]
    I --> A

Guardrails

  • Do not paste secrets, credentials, or client-confidential data into AI tools that are not approved for it.
  • Verify any factual or security-sensitive output; AI can be confidently wrong.
  • AI does not approve its own work: a human is always the approving reviewer and the accountable author.

Example

A developer picks up a moderately complex API change. Instead of generating code immediately, they have the AI tool produce a short implementation plan against the existing service, confirm it matches the design, then implement with AI assistance and generated unit tests. They run the static-analysis gate, let an AI first-pass flag issues, then open a normal PR for human review. After merge, they have the AI update the repo's Markdown API docs and the Mermaid sequence diagram in the same PR.