We presented on AI, vibecoding, and automation. The plan was simple: show practical examples of how we use AI agents to write, review, and debug code, and demonstrate the mindset shift needed to embrace automation in daily development workflows.

For us, the most value came from the conversations around our sessions. We learned from people who have already integrated AI into their workflow and discovered new use cases from developers who are curious and see the potential.

In a market where only about 13.5% of European enterprises report using any AI at all, those individual stories say a lot about where the real movement is happening.

Real Questions, Real Tasks

A product owner asked if we could sit with her team for a few hours to identify automation opportunities and help them adopt AI coding agents. That's exactly the kind of focused, team-level work that turns "we have licenses" into "we've actually changed how we build," which is where European companies are still catching up.

One engineer wanted to know if AI coding agents could handle a niche programming language in a legacy system. After a short demo using contextual prompts, they saw it was viable. This lines up with what many large companies are doing now: not rewriting everything, but using AI to understand and modernize legacy systems in place.

Another developer asked about generating release notes and technical documentation automatically. Someone else wanted guidance on secure setups so we don't leak code while experimenting with agents and automation tools. Those two themes show up in almost every recent study: AI is great at boilerplate (release notes, docs, tests) and at the same time, IP and data privacy are the top reasons teams hesitate to go beyond experiments.

People asked about test-driven development with AI coding agents, integrating tools like Figma MCP and Dev Tools, or automating integration tests. Across the industry, this is where AI coding agents shine: combining TDD or strong test suites with AI-generated code, and wiring tools directly into dev workflows so the agent has real design and code context instead of guessing.

From Demos to Real Adoption

What stood out: people asked about specific, real tasks they want to optimize, and they saw the potential and felt inspired. That's consistent with what we see in productivity data: tools like Copilot show up to 55% faster task completion on routine coding, but only when they're used on concrete, well-scoped work, not as a vague "AI in the IDE" add‑on.

The atmosphere also changed. The first morning felt slow and cautious. By the second afternoon, the discussions were focused, concrete, and collaborative. Many companies report the same pattern: the shift from skepticism to collaboration typically happens once people see their own tasks accelerated, not just a generic demo.

If roughly 1/3 of developers were using AI tools in a meaningful way before this event, we expect the number to grow to 50% in the next months. And not "AI for chatting," but AI integrated into coding, reviews, automation, and internal workflows.

That curve is almost a microcosm of what's happening in large European enterprises, where generative AI use in big companies is heading toward 65-80% in the next couple of years, but only the teams that embed it into everyday workflows see real value.

A Simple Plan for Companies That Want to Do This Well

For teams or companies trying to give their developers access to AI tools and actually get value out of them, a lightweight plan could look like this:

1. Start with access, guardrails, and trust

• Offer a small, curated set of tools (for example Copilot/Codex + one chat/agent interface) and roll them out with clear guidance on privacy, IP, and what code can or cannot be shared.
• Pair the rollout with a basic security model (RBAC, secret scanning, clear "no production secrets in prompts" rule) so people feel safe to experiment instead of worried about leaks.

2. Anchor on a few practical use cases

• Pick 3-5 concrete workflows to improve first: release notes, test generation, refactoring, documentation from PRs, integration test scaffolding, exactly the kinds of asks that came up in the workshops.
• Measure simple, visible metrics here (time to write tests, time to write release notes, time to onboard to a service) and share those wins internally to build momentum.

3. Run hands-on workshops instead of slide decks

• Host short, focused sessions where engineers bring their own repo and tasks, and facilitators help them apply AI tools to real problems in real time.
• Make sure security and legacy questions are explicitly on the agenda (how to handle niche languages, how to keep code private) so concerns are surfaced and addressed, not pushed into shadow use.

4. Create an internal AI circle or guild

• Invite the people who are actually using the tools and let them meet monthly to share prompts, failures, patterns, and mini-demos, the way you're doing with your 16‑person circle.
• Use that group as a feedback loop: they can refine best practices, highlight tool gaps, and help other teams avoid known pitfalls like security issues or over‑reliance on "vibe coding" without tests.

5. Turn practices into shared internal tooling

• As patterns emerge (e.g., good prompts for your stack, a standard way to generate release notes, safe defaults for legacy systems), wrap them into internal scripts, templates, or lightweight tools and document them.
• This is where the big productivity gains appear: from teams sharing the same AI‑enhanced workflows across services and departments.

Bonus: Avoid This Common Mistake

Don't ship AI-generated code without developing conviction in it first.

Using AI coding agents should shift your energy from authorship to review. The temptation is to treat AI-generated code as "magic" that just works, but that's exactly how technical debt accumulates.

Instead:

• Read every line carefully before submitting a PR. Understand what the code does and why it works.
• Develop your own conviction in the solution. If you can't explain it to a teammate, you're not ready to merge it.
• Balance speed with rigor. Yes, AI makes you faster, but code quality and maintainability still depend on human judgment.

When developers skip this review step, they create a dangerous pattern: fast iteration with low understanding. That might feel productive in the short term, but it erodes code quality and team trust over time.

Ready to make this shift? Our hands-on workshops cover the practical fundamentals of AI adoption, coding agents, automation, and the 5-step framework that moves teams from hesitant to hands-on in days, not months.