The commercetools AI-first engineering journey: From autocomplete to near-universal adoption

If there’s anything that makes commercetools AI-first, it’s this: Encouragement and support for AI adoption within daily routines across all roles. That fluency powers both internal productivity and the products our customers rely on.

For example, our Smart Product Modeler leverages AI to analyze product catalogs and suggest structured data models, helping brands launch faster and with higher-quality data. Similarly, our AI Assistant empowers developers and product teams to get answers, recommendations and code suggestions directly in the commercetools’ technical documentation. 

These capabilities reflect the fact that AI has been embedded into our culture from the beginning, since 2021, and it has not been bolted on lately.

This level of adoption didn’t happen overnight. Over four years, we went from evaluating GitHub Copilot with 34 engineers to near-universal AI usage across product development. All without mandates or top-down directives. Instead, we followed a deliberate, bottom-up process of evaluation, choice and learning.

This is our journey toward becoming an AI-first company.  

The public AI-in-engineering story began when GitHub announced Copilot for Business. Engineers across commercetools were eager to try it, so we launched a three-month evaluation with 34 engineers across frontend, backend, SREs, test automation and documentation.

Key results were promising:

• 95% felt more productive.

• 57% used it every day.

• 100% wanted to continue using it.

Copilot excelled at writing tests, autocompletion, scaffolding and refactoring, while struggling with complex business logic. The evaluation worked and we rolled it out more broadly.

Over the next two years, we focused on habit-building, internal upskilling and exploring AI’s limits. Engineers learned when to trust AI and when not to, setting the stage for more advanced tools.

During that time, around half of our engineering team used Copilot, taking advantage of what it offered. Autocomplete on steroids, essentially.

We experimented with automating repetitive work — refactorings, migrations, documentation — but found that models weren’t yet capable of handling complex tasks reliably. But we wanted to leverage AI more and more to automate repetitive tasks and make us more efficient. 

Did it work? Partially. The AI models of that time weren’t ready. But our team built the habit of tapping into AI more frequently, iterating and automating where possible, and that’s been an important part of creating an AI-first culture.

By 2024, IDE-integrated AI tools had matured. A small internal evaluation introduced Cursor, alongside Copilot. Engineers chose tools that made them most productive.

• Copilot: Strong at autocomplete and scaffolding.

• Cursor: Stronger at agent-based workflows and autonomous editing. 

The result was a roughly 50/50 split between Copilot and Cursor users, and we managed to push AI adoption to around 70% of our people. This included not just frontend or backend engineers, but also Site Reliability Engineers,  Solution Architects and product managers, as well as UX/UI designers.

By mid-2025, we recognized that AI wasn’t just an engineering concern anymore. We needed to learn across departments. This realization led to the AI activation initiative, a company-wide program designed to make AI accessible to everyone in two phases: 

1. Training sessions tailored to experience levels.

2. Try-AI-thon, a hackathon spread across three weeks, every Thursday and Friday. Ideas could be submitted by anyone across the organization and cross-functional teams were formed to maximize success. 

We ran 20 internal projects. The demo day shared knowledge broadly and reinforced what we could achieve with AI. The focus was always on enhancement, not replacement. Whether people build, lead, plan or execute, understanding AI empowers you to shape what comes next rather than react to it.

After Claude Code was announced in May, we decided to evaluate it as the next addition to our AI tool belt to explore its terminal user interface (TUI), offering a fundamentally different way to interact with AI. A small pilot group of 10–15 people focused on prototypes, greenfield projects and SRE or backend brownfield work to test its capabilities.

The team was impressed by its potential but noted that working with a terminal-based AI agent required a different mental model, workflow and trust compared to editor-integrated assistants. 

We documented the experience, added Claude Code as an official option in our tool belt, and implemented a rotation-based access system to fairly distribute seats while managing budget constraints.

Interest in Claude Code exceeded the limited seating capacity quickly, so we removed seat limits and enabled broader access. Alongside Claude, engineers now choose from OpenCode, pi.dev and other tools. The tool belt grows organically, based on what people find productive.

It’s worth noting that this adoption is not limited to engineering. Product development and other teams integrate AI where it has the highest leverage, creating an AI-native culture across the company.

We’ve reached near-universal AI adoption across product development, with over 95% of individuals having chosen their own tool combination based on their needs.

A few things made this possible:

• No formal mandate. This happened through a four-year process of embedding AI as a new tool into the organization. Bottom-up evaluation, not top-down directives.

• Choice over prescription. People pick the tools that make them productive. Some prefer Copilot. Some prefer Cursor. Some live in the terminal with Claude Code. Some combine all of them.

• Continuous evaluation. A lightweight process where a smaller group inspects usefulness before wider rollout. Always evaluating, never rushing.

• Community over processes. We established anonymous bi-weekly AI meetings where people share experiences and learnings in a non-recorded, informal setting. No judgment. Just peer learning and idea exchange.

But what surprised us most isn’t the adoption number, but what people do with these tools once nobody’s watching:

• Automating daily routines by integrating Obsidian and JIRA.

• Sandboxing Claude Code with a separate UNIX user for permanent YOLO mode.

• Using voice-to-text to talk to Claude instead of typing.

• Building custom MCPs to improve incident management.

• Centrally collecting skills for Grafana dashboards, service quality checks and dependency updates. 

We’re sure not all improvements have been shared publicly yet, and that’s fine. Ideas start small and so does exploration.

Using AI is no longer just about generating content; it also supports reading and reviewing it. When AI can produce code at speed, the constraint moves to understanding, validating and integrating that output.

That’s where we’re investing now, following the same approach that got us here: Evaluate tools through a lightweight process, let a smaller group validate their usefulness, and then roll them out more broadly. We’re looking at tools to ease code review and content review. We centrally share and document external MCPs, CLIs and skills we consider valuable.

Our AI proficiency in product development isn’t just an internal story; it’s a culture shift that enables commercetools to build sharper AI-powered products. As mentioned previously, we recently launched the Smart Product Modeler, which uses AI to analyze product catalogs and suggest structured data models, and this is a direct example. 

Building it well required the kind of practical AI intuition you only develop through years of daily use: Knowing when to trust model output, how to keep humans in control and where AI adds real leverage. Patterns we prove internally, from custom MCPs to automated quality checks, inform what we build into the platform.

Four years in, the lesson is straightforward. AI adoption isn’t a switch you flip. It’s a culture you build. One evaluation at a time, one tool at a time, one person at a time.