DEV Community

Cover image for What team-wide AI adoption actually takes
Peter Kim Frank
Peter Kim Frank Subscriber Community Curator

Posted on AI-assisted

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.

Top comments (4)

Collapse
 
mickyarun profile image
arun rajkumar •

"Turn what works into rules" is the one I would defend hardest, and for a reason you only half say. An experiment that stays a prompt is also a control nobody can audit. Once it is a scheduled job, you can ask when it last ran and get an answer. While it lives as a habit in someone's chat history, the honest answer to "is this happening" is that you do not know.

Where it gets harder is the collision between building in public and what you are allowed to paste. We handle payments data under FCA authorisation, and the prompts with real leverage are the ones containing a customer record, a transaction, a support thread. Those cannot go in a shared channel. So the work that ends up visible to the team is the chore work, and the judgment calls stay private, which is the opposite of where you want the learning to happen.

The version that holds up is not a policy document. It is that the shared artefact is the prompt with the data removed, plus the tool that fetches the data when it runs. People learn the shape without the payload moving. It is more work than pasting a thread and it is the only version that survives a review.

Your humanoid analogy holds up for the tools. I would add one thing: the general-purpose one wins partly because nobody has to decide which arm to buy before they know what the job is.

Collapse
 
timmyzinin profile image
Tim Zinin •

The move from private experiments to a shared workflow seems to depend on showing the correction as well as the result. For a recurring task, what evidence do you make visible so teammates can distinguish a completed run from one that only started?

Collapse
 
alexcodebytes profile image
Oleksandr •

The distinction between experimenting with AI and operationalizing what works is probably the most important point here. A clever workflow built by one power user isn't team adoption until other people can discover it, understand it, and rely on it without needing that person to maintain it.

I'd add one more requirement: shared visibility shouldn't automatically mean shared access. Teams need to see how workflows operate and reuse successful patterns without exposing private messages, sensitive documents, or credentials to everyone. That balance between collaboration and permission boundaries is essential.

I also like the idea of turning successful experiments into deterministic scripts or checks. AI is excellent for exploring possibilities, but once a workflow becomes business-critical, predictability matters more than novelty. The real measure of adoption isn't how many people have tried AI; it's how much dependable work the team can accomplish with it.

Collapse
 
workdaytrainings profile image
Workday Trainings •

On the ops and HR side, what decides adoption isn't enthusiasm, it's the review step. Every output gets checked by someone who signs their name to it, so the only AI work that survives is work a reviewer can verify at a glance: a reconciliation that ties, a document with the right clauses, a schedule that respects the stated constraints. Anything needing a second opinion to judge doesn't make it past week two.

The power users are also the people with the least slack, so the second wave is coordinators and admins, and a general tool doesn't help them. What does is one worked example per recurring task, with the version that passed review saved next to it.