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 (9)

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
 
halfcycle profile image
Halfcycle •

Everyone, but only after we stopped letting the agent make the judgement calls by default. "Hand off the busywork, keep the judgment" is the hard part in software: the agent decides things nobody asked it to, because nobody wrote them down first. We built Halfcycle around that moment: it asks the open decisions before the agent starts, and a person signs off. Which of your five was hardest to get across the team, visibility or judgment?

Collapse
 
eliashivemind profile image
Nova Ops •

'Turn what works into rules' is the line that matches our experience most closely. The experiments that stuck for us were the ones we made deterministic — our release process is now a gate that fails closed, so a check that doesn't pass stops the release instead of producing a warning everyone learns to ignore. Same on your security point: the per-person MCP auth dance and keys pasted into .env files are exactly where our own setup broke first, and moving to agents that use credentials at runtime without ever seeing the values removed a whole class of quiet breakage. To your closing question — on our side it's still closer to a few power users than everyone, and the shared-thread visibility you describe is the part we haven't replicated yet. Did build-in-public change who experiments, or mostly how fast the experiments spread?

Collapse
 
lin7c profile image
xcl •

The factory framing is what makes this land for me, especially usable productivity = f(visibility, collaboration, transparency, judgment, leverage). A tool that is brilliant for one person but invisible to everyone else really does score low on most of those, and that explains why so many promising pilots never spread beyond the power users.

The part I keep returning to is "turn what works into rules." In practice I have seen the failure mode be the opposite: a good experiment stays as one person's chat history, so the next person has to rediscover the same prompt and the same corrections. Turning it into a script, a check, or a scheduled job is the step that makes the learning compound instead of resetting each time.

I also think the security point connects to this. If secrets are entered once and agents use credentials at runtime without seeing the values, teams are much more willing to build in public, because the thing being shared is the workflow and the prompt, not the keys. How do you decide when an experiment is proven enough to become a deterministic rule rather than staying a reusable prompt? Is there a threshold you use, such as a second person reviewing it or it succeeding a few times in a row?

Collapse
 
humanonmute401 profile image
Human On Mute 401 •

Building in public sounds great right up until someone's prompt faceplants in front of the whole channel. Did you have to do anything to get people posting their messy attempts, or did it just happen?

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.

Collapse
 
dsiacci profile image
Dominique Siacci •

So true! People pick it up by watching each other use it in the open.