E-commerce company, owner-led
We tested Agentic Engineering on the team’s own code
The engineering team at an owner-led e-commerce company wanted to test agentic tools on its codebase and develop shared rules for their use.
| Industry | E-Commerce |
|---|---|
| Services | AI Workshops, Agentic Engineering |
Individual AI practices made shared reviews harder
Developers on the team were already experimenting with coding agents. Some had them add tests; others had them draft extensive changes. Results depended heavily on the codebase knowledge developers provided. During review, it was often unclear which assumptions lay behind a change and what had been checked.
Technical leadership wanted a consistent approach. A demonstration on an unrelated example would have said little about their own architecture. The team needed to use its interfaces, conventions and existing tests to learn where an agent helps and where additional review remains necessary.
The workshop had to deliver a verifiable workflow
Our task was to support a practical workshop on the team’s own codebase. Participants needed a configured toolchain, clear quality rules and a plan for tracking benefits later. Production changes still had to pass the existing review and approval process. The workshop would demonstrate suitable tasks and limits through work the team performed.
We connected the toolchain to the team’s rules
Working context was documented in the repository
The team recorded architecture boundaries, relevant commands and domain conventions. The agent could refer to the same reviewed context as the developers.
Assignments received verifiable boundaries
We described changes with their expected effect, affected interfaces and acceptance criteria. Unresolved assumptions had to be clarified before broader work began.
Quality checks stayed in the familiar process
Tests, static analysis and human review remained mandatory. Developers paid particular attention to error cases, permissions and unexpected changes outside the assignment.
The measurement plan included rework
The team agreed to track comparable tasks through implementation, review, corrections and later defects. Code production alone did not count as sufficient evidence of benefit.
Developers worked on their own changes together
Beforehand, technical leadership and developers selected bounded tasks from the backlog. The working environment contained test data and limited access. In the workshop, we alternated between shared demonstrations and individual work. Developers explained their assignments, let the agent work and then reviewed the entire diff.
An interface change showed that passing tests did not rule out gaps in business logic. The team added a counterexample and tightened the assignment. We discussed the cause directly in the code. This produced a concrete rule for similar changes, which the team added to the repository context.
We initially limited agents to manageable changes. This required more preparation from developers. In return, diffs remained reviewable and incorrect assumptions were easier to spot. Larger changes were recorded as later experiments with their own acceptance criteria.
In the final working session, the team presented successful and discarded approaches. Technical leadership took responsibility for maintaining shared rules and incorporated evaluation of the measurement plan into existing engineering discussions.
The team could use agents under shared rules
Developers had experienced which assignments produced useful results on their own codebase. The toolchain, context and quality checks were in place. Further adoption had suitable task types and a measurement plan that accounted for review and rework. Technical leadership could use these to guide everyday use.
Agentic benefits must survive the review process
Your own code reveals the actual limits
Work with existing interfaces and tests so the workshop produces decisions for daily work.
Assignments need domain-specific counterexamples
A passing test run does not replace checking whether a change handles undesirable cases correctly.
Measure work through acceptance
Include review and corrections before concluding that faster code generation reduces workload.
A first conversation takes 30 minutes.
We discuss which tasks from your codebase suit a practical Agentic Engineering workshop.