Back to Blogs
#ai#productivity#discuss

What team-wide AI adoption actually takes

I've tried nearly every way to make AI practical at work: new models, routers, agent frameworks,...

4 min read
Cover for What team-wide AI adoption actually takes

I've tried nearly every way to make AI practical at work: new models, routers, agent frameworks, spreadsheet plugins, Telegram bots, iPhone Shortcuts, email workflows. Getting one person productive with AI turned out to be easy. Getting a whole team to use it every day is a different problem, and the model is rarely what's in the way.

What it actually takes is a shift in mindset and tools that fit how the team already works.

Build the factory, not just the engine

Better models and more compute are the engine. They don't make a factory on their own.

In software, we already know the factory is orchestration, review, testing, and CI/CD around the code. Knowledge work needs the same thing, and what you're after is usable productivity:

usable productivity = f(visibility, collaboration, transparency, judgment, leverage)

A tool that's brilliant for one person but invisible to everyone else scores low on most of those.

The mindset

Build in public. Adoption is a team sport, and people learn AI by watching each other use it. If the work happens in private chats and personal terminals, nobody else picks anything up. When it happens in shared channels and threads, everyone can see the prompt, the result, and the correction, then join in and reuse it. The manifesto this post grew out of was dictated by voice in Slack and built live in a thread, in the open.

Hand off the busywork, keep the judgment. Let AI take the repeatable chores: pulling numbers, checking a test email, setting up the same spreadsheet again. People decide at the moments that matter. The limit stops being headcount and becomes our creativity, ambition, and judgment.

Experiments are cheap now. A proof of concept costs minutes, so ask for more than you think you should. One teammate asked an agent to regenerate a day's emails for comparison, then added: "Also, a diff view would be wonderfully helpful." A greedy ask, in the best way. Build it, learn from it, throw it away if it doesn't work out.

Turn what works into rules. When an experiment proves itself, make it deterministic: a script, a check, a scheduled job. That's how AI-generated "slop" becomes resilient code the team can rely on.

The tools

Think humanoid robot. A humanoid isn't the best robot for any single job. A purpose-built arm welds better and a Roomba vacuums better. But it's the best general-purpose robot, because we live in a world built for humans: stairs, door handles, tools sized for hands.

Our working world is made of chat channels, threads, and docs. The AI tools that get adopted are shaped to fit that world and meet people where they already work, instead of asking everyone to move into one more window.

Give work a shape. One endless chat doesn't scale to a team. Projects, work streams, and threads give every task a place, so people can find it, pick it up, and build on it across team boundaries.

Make integrations just work. If connecting a tool means an MCP auth dance per person, most of the team never gets past setup. Native integrations, Google Docs included, that the whole team connects once are what make AI useful outside engineering.

Make security nobody's homework. Today, rolling AI out to a team often means asking less technical people to manage their own secrets. That setup breaks easily, and it doesn't scale.

What it usually looks like:

  • API keys pasted into .env files on every laptop
  • everyone inventing their own security habits
  • MCP servers running on localhost, one setup per person
  • auth that breaks quietly and needs an engineer to fix

What it should look like:

  • secrets entered once through a secure form, never pasted into chat
  • agents that use credentials at runtime without ever seeing the values
  • integrations connected centrally, with nothing running on anyone's laptop
  • one shared setup the whole team inherits

Much less brittle, and far easier to adopt. While you shouldn't absolve the team of understanding security considerations, you also can't be naive about human behavior at scale.

Don't force tradeoffs. Good team tooling gives you both sides:

  • scheduled automations and on-demand help
  • many models and one place to use them
  • fresh cloud machines and your own hardware
  • autonomy and a human in the loop when it counts
  • exact code for what must be right and model judgment for the messy parts

What we use

For our team, Capy has been the closest thing to that humanoid robot: it lives in Slack, its integrations (Google Docs included) actually work, work is organized into projects and threads, and the security setup is handled centrally. Several of our recurring workflows now run through it. It's not the only way to get there, but if you're picking AI tools for a team, weigh these things at least as heavily as benchmark scores.

Over to you

How is your team using AI day to day? Is it a few power users, or everyone? I'd especially love to hear from teams that aren't mostly engineers.