Skip navigation EPAM
Dark Mode
Light Mode

Buy Tools or Build Scaffolding for Outcomes?

TL;DR

  • Most orgs don’t fail at AI, they fail to scale and sustain impact. The loop is predictable: chase a do-everything platform; commit budget before anyone sees results in production; rack up A-team wins that don’t generalize; bolt on measurement after the fact—then the ground shifts as LLMs and tools evolve and you’re locked into yesterday’s assumptions.
  • What works is disciplined and repeatable. Prove value in production on live backlog under real constraints; set acceptance up front and integrate where teams already work with hands-on support. Instrument from day one (DAU, acceptance ratio, throughput, PR cycle time, defect leakage, rework, cost per unit). 
  • Build the scaffold so average teams win—golden paths, office hours, playbooks—run it as a program with a local AI Engineering CoE, clear pillars (AI Dev Ecosystem, SDLC/value-stream efficiency, Measurement, Education, Change, Governance, ROI), and a maturity path with coaching in context.
  • Design for heterogeneity and swap-ability, fit-for-purpose tools, integrated at existing interfaces; specialization is normal (agentic IDEs, quality-engineering agents, modernization toolsets). Keep a small Alpha team probing the next horizon and shipping scoped, production-adjacent trials; publish what moved.
  • Blend top-down intent with bottom-up champions—allocate capacity and pair mandate with local ownership.
  • Match commercials to reality: time-boxed production tries with off-ramps; defer long commitments until results land.

Here are the traps I see most often- each could be its own conversation- this pass is the map: 

Specialize the stack. Unify the flow

Trap: Hunting for a single “best” agentic platform—and expecting it to cover everything (engineering acceleration, testing, product managers support, reverse-engineering, modernization, toil automation)—slows time to value.

General-purpose vs. specialized models is a real trade-off; the same applies to applications. Agents are constrained by their deterministic tools and ability to orchestrate them, so forcing one stack narrows outcomes.

Over-concentration on the AI toolset pulls attention away from other equally important work—choosing right use cases, Integrate where teams already work, so AI can tap project data in place and reuse existing interfaces, developing team-level champions, and setting delivery scaffolding. And while you’re standardizing, the ground keeps shifting—locking thinking into one stack too early.

What Works: Assume heterogeneity. Different use cases deserve different tools—that’s healthy. Let teams combine what helps them ship (e.g., Cursor + Claude Code) within clear guardrails. Optimize for fit-for-purpose and swap-ability, not a single winner. Specialization is the norm today—agentic IDEs, autonomous agents, quality-engineering agents, and modernization toolsets tied to a tech stack or 7R-aligned modernization paths.

Design for choice: define selection criteria for each major use case, cap costs at the team level, and conduct regular productivity reviews to retire laggards and double down on winners. Allow 2 to 3 endorsed stacks per use case, with quarterly reviews. Make switching inexpensive by teaching agentic interactions, building strong fundamentals, and integrating into existing interfaces.

Don’t buy (or commit) before a real production try

Trap: "Everyone shows the same slides, and the pitch sounds familiar". Many AI vendors also have immature pricing: higher-usage tiers and “AI-included” bundles pushed to optimize margins, even when the extra capacity isn’t needed by most enterprises. I even came across an AI vendor pushing a multi-year, six-figure contract on the first sales call—before offering a demo.

Regardless, delivering in practice is harder. A sandbox PoC is not a production trial. Real scale, accumulated tech debt, SDLC / value-stream quirks, and teams used to their current tools and habits change the outcome—often a lot.

What Works: Run a real production try on a representative product and team, using live backlog work. Set acceptance criteria up front: which flow, quality, and economics you expect to move; how you’ll baseline; how results will be reported. Keep the enablement real—meet teams where they are, and provide hands-on support so the evaluation captures actual use, not a demo loop.

Expect some teams to struggle for reasons unrelated to the AI toolset—delivery pressure, resistance to change, early bumps integrating AI toolchains into the current process. Capture those lessons, update the playbooks, and only then decide on broader rollout.

Commercials should match this reality: time-box the production try, include off-ramps, and defer long commitments until results are proven in production.

Scale with repeatable scaffolding

Trap: A lot of AI adoption efforts start with A-team of curious senior engineers—fully bought into the “AI is the way” idea, spending extra time to learn, motivated by using AI on their project or building AI tools. These teams are a great alpha to explore new territory and prove value. But they’re not the organization.

The average engineering team is busy working through a backlog under delivery pressure. Many aren’t excited about AI tools—for different reasons—and that’s fine. Without repeatable scaffolding - clear guidance, quality playbooks, hands-on support, pair-programming, and help unblocking real challenges - adoption stalls the moment you leave the A-team bubble.

What Works: Treat adoption as a deliberate program, not a vibes-driven experiment. Put experienced leaders in charge who’ve run this play before and operate from repeatable frameworks tested on other production engagements. Bring hands-on experts for each function that’s changing—Software Engineering, Quality Engineering, Product Management—so teams aren’t left to “figure it out” while shipping.

Stand up a local AI Engineering CoE to tailor the scaffold to each product team and role. The CoE curates best practices and playbooks, seeds and tracks AI champions, and keeps the program coherent as tools and patterns evolve. Build on clear pillars: AI Dev Ecosystem, SDLC / value stream efficiency, Measurement, Education, Change Management, Governance, and ROI—and make ownership explicit for each.

Plan the maturity path up front. Define what “good” looks like per pillar, how it advances quarter over quarter, and which checkpoints unlock broader rollout. Keep the loop tight: coach in context, measure actual flow and quality changes, publish results, and adjust.

Momentum needs a scoreboard

Trap: Experiment with AI tools, get the dopamine from models giving you exactly what you want—it’s rewarding. Report success, show the value, run live demos, showcase real-world use cases saving hours. All of that is cool. However, it doesn’t help you clearly articulate—at the next budgeting cycle—a hefty bill for extra AI spend, with every sign it will keep increasing (likely exponentially) on top of the current spend. In the current environment, with few exceptions, that message won’t land well with the CFO, CEO, and the Board.

What Works: Establish AI adoption and delivery productivity day one.

The former is more straightforward part. Satisfaction surveys and AI-tool telemetry data are solid inputs that cover most of it.

Productivity measures are the usual struggle for software engineering teams. The approach is clear and the metrics are known, but it takes effort to wire the processes and tools, and discipline to follow them. That’s where things often go south. In AI productivity measurement, what often happens is the desired metrics don’t move; AI value gets buried under layers of interconnected KPIs that demand patient data exploration and analysis.

Locking in is falling behind 

Trap: Some organizations moved early, ran organized rollouts, showed results—and then locked in gains instead of riding the winners. AI adoption programs don’t plateau. The stack and practices keep maturing; the post-hype potential keeps shifting. There’s always more value to unlock if you keep doing the work. Each iteration gets more complex and, in many ways, depends on how mature the prior phase became—process, tools, and teams included.

What Works: Assume a next horizon is already forming while you’re scaling the current one. By the time a quarter or two of adoption work lands, new capabilities will be ready to try.

Keep a small alpha track—internal or with credible partners—continuously exploring the space. Ship scoped, production-adjacent trials, publish what moved (and what didn’t), and have a standing plan to push the art of the possible inside your org every few quarters. That keeps momentum on winners without stalling the mainstream path.

Set the north star, let teams steer

Trap: Blurring where decisions live and where engagement happens. This is a senior-leadership matter—like any major change in company operations. It doesn’t have to disrupt roadmaps or major releases, but it does require time allocation from teams and, more importantly, changes to tools, processes, and people’s entrenched ways of working. When leaders signal intent without making those changes, “do AI” becomes side-of-desk work. It must become a clearly articulated company strategy and part of the software engineering organization’s DNA—or efforts fragment and stall.

A pure top-down push won’t work either. Each team needs a local AI champion, someone genuinely interested who will lead local adoption. Without that, resistance (often for valid reasons) goes unaddressed. Momentum dies because no one is maintaining a positive exploratory spirit or helping the team work through bumps on the road.

What Works: Get explicit alignment with executive leadership on the AI adoption strategy: why we’re doing this, what near-term actions we’ll take, who is accountable, and how we’ll communicate it.

Make time and expectations visible, allocate capacity so teams aren’t asked to “do AI” off the side of the desk. Identify AI champions organically from the teams. Ideally they’re respected, hands-on technical leaders; this is also a good opportunity for emerging leaders to step up.

Pair the mandate with local ownership: executives set direction and provide cover; champions run the play in context, integrate where teams already work, surface issues early, and feed learnings back into the program so adoption stays real and repeatable.

Its a tough journey. Failures are inevitable. Stay in motion. Fair attempts beat idle perfection.