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
.envfiles 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 (15)
This is a great perspective! I particularly agree that successful AI adoption is about building repeatable workflows, not just giving everyone access to AI tools. One important factor is making those workflows measurable, so teams can track accuracy, identify failures, and know when human intervention is needed. At IT Path Solutions, connecting AI capabilities with existing business systems and building reliable automation is an important part of creating practical AI-driven solutions. The real value comes when individual experiments turn into dependable processes that the entire team can use.
'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?
the 'give work a shape' bit is the one that explains why our team chats never turned into adoption — one endless thread where nobody can find anything, versus a project where the work actually lives somewhere. the model was never the bottleneck, the shape was
"Tools that fit how the team already works" is the part I would underline, because it is usually where adoption is decided, long before anyone compares models.
We saw the same pattern outside AI at Ascendra Ventures. An IT services firm ran its service desk on Genesys Cloud, but its users lived in Microsoft Teams, so raising an issue meant leaving the place they worked for a portal, an email or a phone call. The fix was not a better portal. It was a Teams bot: type Hi and you are routed to a live agent within seconds, the agent's replies come back into the same chat, and status updates arrive where the conversation started. Once that bridge existed, the same setup was reused for automated incident reporting and a chat component inside low-code business apps. The tool did not change much. Where it lived did.
Your build in public point feels like the same idea applied to prompts. Which of the five took longest for your own team to accept?
The build in public part matches what I've seen too, people copy what they can see a teammate doing way faster than any doc. Turning experiments into scripts and checks is a good way to keep the slop out.
The strongest line here is 'turn what works into rules' - and it hides the trap. A script or scheduled job wrapping an LLM is only as deterministic as the model version behind it: that 'resilient code' silently changes behavior the day the provider ships a new default model, and nobody on the team owns that regression. If you make experiments deterministic you also need a pinned model plus a golden-set check that fails loudly, otherwise you've just moved the slop from chat into cron.
'Build in public' has a cost you don't mention either: shared channels breed prompt monoculture. The one prompt that worked once gets copy-pasted by everyone - including the correction that happened to be wrong. Visibility spreads mistakes at the same speed as wins, so what needs to be visible is the evaluation (what the output was checked against), not just the prompt and the result.
"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.
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?
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?
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.