Ship it · Step 14 of 14

AI on your team

Getting one developer productive with AI is easy. Getting a team to adopt it well — consistently, safely, without theater — is the real problem.

Start with the workflow, not the tool

Adoption fails when it's framed as "everyone use this tool." It works when it's framed as "here is a slow, annoying part of our week — here is how AI removes it." Find the friction first; the tool is the easy part.

Where AI fits in the dev loop

Writing code

First drafts, boilerplate, unfamiliar APIs, one-off scripts. The author still owns and reviews every line.

Code review

A fast first pass over a diff — risks, edge cases, missing tests — before a human reviewer spends their time.

Tests & docs

Generating test cases from a function, drafting docstrings and READMEs — the work that always slips.

Debugging

Pasting an error and a stack trace to get hypotheses fast, instead of a cold search.

Understanding code

Explaining an unfamiliar module or a gnarly regex — onboarding and spelunking in legacy code.

Delegated tasks

Handing a whole, well-specified ticket to a coding agent that works in the background and comes back with a pull request to review.

Toil

Log triage, data reshaping, migration scripts, changelog drafts — the everyday glue work.

Set the guardrails early

A team needs a few shared rules — written down, not assumed — so AI use is consistent and safe:

  • Review still applies. AI-written code goes through the same review as anything else. The author is accountable for it, full stop — "the AI wrote it" is not a defense.
  • Mind the data. Decide what may and may not be pasted into a tool — secrets, customer data, proprietary code — and which tools are approved for which data.
  • Verify before trust. Treat output as a draft until checked. For anything load-bearing, that means tests, not a glance.
  • Disclose where it matters. Agree on when to note that AI was involved — in commits, PRs, or design docs.

Agents change the rules a little

Most teams are past autocomplete: developers now hand whole tasks to agents that edit files and run commands (Coding Agents covered the individual habits). A team needs a few rules of its own.

  • Put the team's knowledge in the repo. A shared instruction file (CLAUDE.md, AGENTS.md) holding the build commands, conventions, and things not to touch gives every developer's agent the same briefing. Review changes to it like code.
  • Decide what agents may do unasked. Reading and editing in a branch: fine. Pushing, deploying, deleting, touching production data: a human approves. Set this in the tool's permission settings rather than relying on everyone to remember.
  • Keep secrets out of reach. An agent can read anything its user can, and can be misled by text in a web page or an issue. Don't run agents where production credentials are lying around. Security has the full picture.
  • Keep pull requests reviewable. An agent will happily produce two thousand lines. Ask for small, focused changes; a diff nobody can read gets approved unread.
  • Watch the bill. Agent usage is priced by the token and varies enormously between people. Look at the spend monthly so it is a decision, not a surprise.
The biggest risk isn't bad code — review catches that. It's reviewers rubber-stamping AI output because it looks confident. Name that risk out loud so the team watches for it.

Share what works

Skill spreads through examples, not mandates. The teams that adopt AI well treat prompts and patterns as shared assets:

  • A lightweight, living doc of prompts and workflows that worked — and ones that didn't.
  • Procedures the whole team repeats, written once as skills in the repository, so everyone's agent does them the same way.
  • Pairing or short demos: someone shows how they used AI on a real ticket. Showing beats telling.
  • A regular, low-stakes channel for "here's a thing I tried."

Measure honestly

Don't measure "lines of AI code" or "prompts per day" — those reward activity, not value, and invite gaming. Watch the outcomes that already matter: cycle time, review time, how much toil shrank, whether quality held. And ask people plainly where it helped and where it wasted their time.

The failure modes

  • Mandating it. Forced adoption produces box-checking. Make the win obvious and let it spread.
  • Banning it. A blanket ban just pushes usage into the shadows, ungoverned. Engage and set rules instead.
  • Expecting magic. Pitched as a silver bullet, AI disappoints. Pitched as a sharp tool with an edge and a handle, it sticks.
  • Skipping the fundamentals. A team that hasn't learned prompting or where AI doesn't help will blame the tool for its own briefs.
Adoption is a skill curve, not a switch. Pick one workflow, get it genuinely working, let the result sell the next one. Momentum beats mandates.

That is the path

You started at why any of this matters and have now covered asking well, managing context, choosing a model, working with agents, building AI into software, measuring it, securing it, and bringing a team along. The field will keep moving — model names and prices on this site carry a "last checked" date for that reason — but those habits are the part that lasts. The best next step is not another page: pick one slow, annoying thing in your week and build the tool that removes it.