Software Development

raw idea / stakeholder ask → problem statement → PRD → technical design doc → estimated backlog (epics → stories with acceptance criteria)

• Automate
  Intake triage — AI clusters incoming requests, flags duplicates against the existing backlog, and drafts a one-paragraph problem statement for each · high volume, low stakes, and a human sees every output downstream anyway
• Draft
  PRD drafting — AI interviews the requester, mines Slack threads and support tickets for context, and produces a structured PRD with open questions listed · context is scattered and partly tacit; the owner must confirm the problem is actually the problem
• Assist
  Scope negotiation — AI generates trade-off options and a "what we're explicitly not doing" list; the PM runs the conversation with stakeholders · this is relationships and political capital, not rules — the artifact is an agreement, not a document
• Draft
  Technical design — AI proposes 2-3 architecture options with trade-offs against the existing stack; a senior engineer picks and edits · consequential and expensive to reverse, but options-generation is where AI adds the most and the human still owns the bet
• Automate
  Story breakdown — AI decomposes the approved PRD into stories with acceptance criteria written as testable statements · mechanical decomposition of an already-approved artifact; errors surface immediately in sprint planning
• Assist
  Estimation — AI drafts estimates from historical velocity and similar past stories; the team adjusts in planning · estimates encode team-specific knowledge AI can't see, and anchoring on AI numbers is a known failure

story + acceptance criteria → implementation plan → agent task prompt → code diff (PR) → passing local tests

• Automate
  Codebase orientation — AI answers "where does X happen, what will this change touch" by reading the repo · read-only, instantly verifiable by looking, and it's the highest-frequency question in the job
• Draft
  Implementation planning — AI writes a step-by-step plan naming the files it will touch and the approach; developer approves before any code is written · cheap to review, expensive to skip — a bad plan multiplies into a bad afternoon of agent output
• Automate
  Writing the code — coding agent implements the approved plan, runs tests locally, iterates until green · this is the domain's showcase: fully verifiable output, high volume, human reviews the diff not the keystrokes
• Automate
  Scaffolding & boilerplate — CRUD endpoints, API clients, config, migrations generated whole · pattern-following work with near-zero ambiguity; the compiler and tests catch the failures
• Assist
  Handling ambiguity mid-task — when the agent hits an underspecified decision (which library, how to handle the edge case), it must stop and ask, not guess · the decision, not the typing, is the scarce judgment; agents that guess here produce plausible wrong code
• Avoid*
  Prompt-to-PR hygiene — developer writes the task spec, constraints, and "definition of done" the agent works against (Avoid for delegation) · this artifact *is* the human's job now; delegating it means nobody specified the work

pull request (diff + description) → AI review pass → human review comments → approved & merged commit

• Automate
  PR description & changelog — AI writes the summary of what changed and why from the diff and linked ticket · fully derivable from artifacts in hand; wrong summaries are caught by the first human reader
• Automate
  First-pass review — AI reviewer flags bugs, missed edge cases, security smells, and style drift before any human looks · high volume, each finding is cheap to verify or dismiss, and it makes human review time land on what matters
• Assist
  Substantive human review — a person judges whether the change is the *right* change: fit with architecture, product intent, maintainability · AI summarizes and answers questions about the diff, but intent-vs-implementation judgment is the review's whole point
• Avoid*
  Merge approval — the human clicking approve on anything headed to production (Avoid automating) · this is the accountability gate; a merge is hard to un-ripple once others build on it, and "the AI approved it" satisfies no auditor
• Automate
  Fix-forward on review comments — agent implements the reviewer's requested changes and re-runs checks · the reviewer specified exactly what to do; the loop closes itself and the reviewer re-verifies

acceptance criteria → test plan → test code (unit / integration / E2E) → CI results → coverage & flake reports

• Automate
  Unit test generation — AI writes tests for existing and new code, targeting branches and edge cases humans skip out of boredom · volume work with a built-in check — the test suite runs; note the trap that AI happily writes tests that assert current buggy behavior
• Draft
  Test plan from acceptance criteria — AI translates each criterion into named test cases, including negative and edge cases · the mapping is mechanical but the *omissions* matter; QA owns deciding what's missing
• Automate
  E2E test authoring & repair — AI writes browser-level tests from plain-English steps and self-heals them when the UI changes · flaky selector maintenance was pure toil; failures are visible in CI within minutes and fully reversible
• Assist
  Exploratory testing — a human tries to break the app in ways no spec anticipated, with AI suggesting attack angles · adversarial creativity against unwritten expectations is precisely the unverifiable part
• Avoid
  Deciding the quality bar — what coverage suffices, which flakes to tolerate, when the suite is trustworthy enough to gate deploys · this policy decision determines how much everyone else gets to automate; it's the load-bearing wall of the whole table

merged commit → CI build + test run → staging deploy → release notes → production deploy → post-deploy monitoring verdict

• Draft
  Pipeline authoring & maintenance — AI writes and fixes CI configs, build scripts, and infrastructure-as-code · verifiable by running, but pipeline changes are the one place a "test" mistake touches production machinery, so a human reads every diff
• Automate
  CI failure triage — AI reads the failed run, distinguishes flake from real break, and either retries or opens a diagnosis with a proposed fix · huge volume, minutes-level reversibility, and the fix still lands via the normal PR gate
• Automate
  Release notes & comms — AI compiles user-facing notes and the internal change summary from merged PRs · derivable from artifacts, low stakes, skim-checked by the release owner
• Avoid*
  Production deploy decision — a human approves promotion to prod, especially for schema migrations and anything customer-visible (Avoid automating) · irreversibility is concentrated here: data migrations and user-facing breakage don't roll back cleanly, and someone must own the pager
• Automate
  Post-deploy verification & rollback — AI watches error rates and latency against baseline and auto-rolls-back on breach per a human-written policy · the policy is the human judgment, encoded once; execution is rules-vs-relationships at its purest and speed is the whole value
• Draft
  Incident summary — AI drafts the timeline and contributing-factors writeup from logs, alerts, and Slack · the record has compliance and blame implications; the incident commander owns the narrative

bug report / EOL notice / audit finding → reproduction & diagnosis → fix or migration plan → incremental PRs → regression-verified system → updated docs

• Automate
  Bug reproduction & diagnosis — agent reads the report, reproduces the failure as a failing test, and localizes the cause · the reproduction test *is* the verification; a wrong diagnosis dies in the open instead of in someone's head
• Automate
  Routine bug fixes — agent fixes the failing test it just wrote, for the well-scoped majority of tickets · high volume, verified by the repro test plus the full suite, reviewed like any PR
• Automate
  Dependency & security patching — agent bumps versions, resolves breaking changes, and opens PRs as CVEs and EOLs land · repetitive, urgent, and fully CI-verified — the canonical "agent does it, humans spot-check" workload
• Draft
  Documenting legacy behavior — AI reads an undocumented old system and produces current-state docs and behavior specs · enormous leverage on scarce context, but the system's *undocumented intentions* need a veteran's confirmation
• Assist
  Migration planning — choosing target architecture, sequencing, and what to kill rather than port · a strategic bet with organizational stakes; AI supplies inventory and options, leadership owns the wager
• Draft
  Migration execution — agents translate and port code module-by-module against a characterization test suite written first · translation at scale is AI's sweet spot, but legacy edge cases are exactly where context is thinnest — humans own each module's sign-off

team pain point → prompt/spec → AI-built app (Retool, Lovable, sheets-plus-agent) → data connections → adopted tool → (ideally) registered, reviewed, owned tool

• Automate
  Building the tool — a business user describes the app and AI builds it: dashboards, form-to-database apps, approval flows · this is the point — the builder is the user, verification is "does it do my job," and the blast radius *should* be one team
• Avoid*
  Connecting to real data — wiring the tool to production databases, HR systems, or customer data (Avoid without IT) · stakes and regulatory exposure jump discontinuously here; a read-write connection to real customer data is not a citizen-dev decision
• Draft
  Workflow automation glue — AI-built connectors between SaaS tools (form → CRM → Slack) with humans approving each new automation once · reversible and low-stakes per run, but silent failures compound, so the owner reviews before enabling
• Automate*
  Governance & registration — IT maintains an inventory of citizen-built tools, their data access, and their owners; AI scans SaaS logs and OAuth grants to find unregistered ones (Automate the discovery) · high-volume detection with human follow-up; you can't govern what you can't see
• Assist
  Promotion to supported software — deciding which team-built tool has become load-bearing and must be rebuilt or adopted by IT · an organizational judgment about criticality and ownership; AI supplies usage evidence, not the verdict
• Draft
  Deprecation & offboarding — retiring tools when their builder leaves, with AI drafting the handover doc from the tool itself · the doc is derivable but the decision to keep or kill needs the successor's confirmation