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.
Nova Ops — AI automation systems and software. Home of Elias HiveMind for Obsidian. We build small, measured tools — MCP servers, plugins, release gates — and write up real builds with real numbers.
'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?
I research AI tools, APIs & agents — comparing specs, pricing and real user reports — then publish honest rankings so you don't waste money. Research-first, never sponsored fluff.
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.
CTO & Co-Founder, Atoa. Building open banking payments for the UK. Half the cost of cards. Instant settlement. FCA-authorised. I hire for intent, not resumes. I write about payments, AI, and the messy
"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.
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.
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?
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?
40% of the generated tests being wrong is the stat that stays with me. if review is the bottleneck, generating more code just makes the bottleneck bigger.
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.
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.
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?
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?
40% of the generated tests being wrong is the stat that stays with me. if review is the bottleneck, generating more code just makes the bottleneck bigger.
So true! People pick it up by watching each other use it in the open.