Some of the most impactful engineering breakthroughs likely make for very boring marketing demos.

Over several decades spent leading development teams, I have seen firsthand how tempting it is to focus engineering efforts on highly visible, flashy new features. I’ve known many developers who get bogged down by the pressure to package every software update with a supremely marketable new element or two that’ll get people talking.

But in my experience, the features that most enhance a user interface are often completely invisible to users.

Performance, reliability and security are not the sexiest features, but they’re crucial elements to a satisfactory user experience. That’s especially true when you’re engineering for users working within complex vertical industries – such as architecture – who count on simple, dependable technology to bring their daily work to life as seamlessly as possible.

My foundational philosophy is that the absolute best software is the kind you can dig into without ever needing to pick up the user manual. Users shouldn’t have to spend valuable time fighting to navigate complex menus, acting as manual data routers who must convert one format to another just to connect the dots. When professionals can focus on using their tool as solely a means to an end rather than a puzzle they have to solve, that is when you know you have done your job well as a developer.

The unsung heroes of successful software: Speed, reliability and security

R&D teams often must fight to justify investing in foundational software improvements because they simply aren’t as visually marketable as shiny new capabilities. But performance is a hidden expectation that great developers cannot afford to ignore.

As a Chief Technology Officer guiding design software development for AEC professionals, I’ve learned modern users have incredibly high standards for speed. This is especially true for younger users just entering the workforce. If they have to wait more than a few seconds for their tool to function as directed, it will come at a cost to their sustained attention and workflow.

Reliability is also paramount for modern tech professionals, particularly as we integrate more automation and artificial intelligence into our workflows. When we implement automation to handle boring, repetitive tasks, our users need to know that the system is worthy of their rock-solid trust and can execute those tasks flawlessly.

To use an example relevant to my market, imagine you’re an architect designing a highly complex, multi-million-dollar project for a new hospital with thousands of rooms. You’re collaborating with dozens of other engineers from multiple disciplines, both structural and electrical, and all of you are working on the same model. If you direct the software to automatically update the wall weights across all the bathrooms in the entire hospital, you’re investing your absolute trust in that software accomplishing the task exactly right without interfering with other modeling being done simultaneously.

If the program is unsuccessful or hinders other parts of the project, the user loses trust in the software and the greater team loses trust in the user. That kind of trust is hard to build back.

And if the mistake is not addressed quickly, it could prove costly – potentially pouring significant additional spend into the project budget and contributing to the $2.1 trillion in project cost overruns that occur globally each year. What starts as a simple glitch in software performance can end with significant damage, the kind that could prevent users from ever going back to that tool.

For a similar reason, security is another pivotal foundational element developers must prioritize. In fact, data protection must be prioritized above all else – especially in fields like architecture where you’re dealing with a lot of precious intellectual property. A software user could not care less if an incredible new, time-saving feature is unveiled if, simultaneously, the software environment isn’t secure and their files are vulnerable to corruption.

Developers must focus primarily on protecting the complex digital assets and sensitive information handled with their software. To bring back our hypothetical architect, imagine a project to upgrade a government intelligence facility, with building floor plans that reveal the locations of secure rooms, surveillance locations, emergency exits and other privileged intel that, if put into the wrong hands, could jeopardize the safety of those working on-site.

Ensuring data is never lost, providing redundant storage and keeping sensitive information safe is our absolute baseline responsibility to users. While we might only briefly mention security enhancements in marketing collateral, it is a continual investment in a secure, reliable environment that keeps good software good.

Learning when what glitters isn’t gold

To measure the true return on investment for our R&D efforts here at Graphisoft, we rely heavily on product telemetry to see what users actually engage with. We recently introduced a brand-new, AI-ready data platform that allows us to analyze anonymized usage logs to see exactly which functions are being used and which are being ignored. This data is essential because if the product team convinces us to build something they believe is vital, we can calculate the development cost and then track if it delivers real value to our users.

A while ago, we unveiled a highly visual, flashy tool for our BIM software platform, Archicad, called the AI Visualizer. We were really proud of this tool. Essentially, users could start with a basic drawing or photo of random objects, such as a stack of boxes on a desk. They could then ask the AI Visualizer to create a skin based on the image or drawing, and the software would generate a high-tech office building or a beautiful wooden structure mimicking those shapes. It was an incredibly enjoying tool for creative work at the very beginning of a conceptual design phase.

Based on our continuous usage data analysis, we determined changes were necessary to retain long-term interest in the AI Visualizer – prioritizing enhancements that advanced open standards and seamless collaboration, rather than focusing too heavily on flashy UI additions. The biggest frustration they face is a lack of multidirectional collaboration capabilities and the tedious manual work required to transfer data between closed systems. So, in response, our team homed in on an open, cloud-agnostic environment where our users never feel trapped or dependent on a single provider.

Openness isn’t a flashy UI button, but allowing users to seamlessly connect their dots, export to any format and integrate with any technology is a massive differentiator for user satisfaction.

As a developer, you want users to choose your software every day because it is excellent – not because you have them locked into a closed ecosystem.

The future of intent-based software

I believe we are currently experiencing a paradigm shift away from traditional, click-heavy interfaces and toward what we call “intent-based design” that allows architects and engineers to specify a destination and letting the software itself figure out how to get there.

Across most vertical industries, R&D teams are building toward an AI-native nervous system that digitalizes common knowledge, allowing software to continuously learn and execute tasks based on a massive internal knowledge graph. This trend will contribute to increased intent-based design – and I believe that even in the near future, the user manual will become obsolete.

Rather than having to manually execute against each step in the engineering process, intent-based workflows allow a user to convey a vision and prompt the software to bring it to life based on the low-level functions and knowledge already built into its system. In architecture, for example, that means prompting your BIM modeling software to design a house within the specific parameters of Frank Lloyd Wright’s architectural style, rather than manually guiding it through each of those individual parameters yourself.

An argument for “boring” R&D

My ultimate goal is for our software to act as a quiet partner to great work. I think about it the same way as working with a great human colleague who you don’t have to over-explain every tiny detail to; instead, they understand where you’re headed as soon as you’re halfway there, understanding you in half the words and getting to work in half the time.

I want our software to behave the same way with, for example, intuitively predicting a user’s next step, seamlessly guiding them through new features without requiring any training. Our goal is to handle boring, repetitive tasks so users can remain fully immersed in their creative flow. With that we can provide immense value while demanding minimal attention, prioritizing what’s functional over what’s flashy.

When it comes to R&D, the sexy new features might get people in the door, but it is the invisible strength, the relentless reliability and the quiet partnership of the software that will keep them loyal.

AI is already changing how software is built. Google Cloud’s DORA research, based on nearly 5,000 technology professionals, found that 90% now use AI at work, spending a median of two hours a day with it, which translates to roughly a quarter of the working day.

In many organizations, the focus is on what happens at the end of the lifecycle: how much code is generated, how many steps are automated, how quickly code is shipped. While those are visible signals of progress, they can be divorced from actual value. Google’s DORA research found that while AI adoption lifts delivery throughput, it also increases instability: more software shipped less predictably.

The more impactful change is happening earlier in the lifecycle. Requirements, design and test strategy shape everything that follows. When those stages are structured correctly, downstream execution becomes faster, more consistent and easier to control. When they are not, issues tend to carry through the entire system, regardless of how much automation is applied later.

The Standish Group’s CHAOS research has consistently put insufficient user involvement and incomplete and changing requirements at the top of the list of reasons projects fail, with only around 31% delivered on time, within the budget and matching the intended scope.

Generalist models are good at producing plausible early-stage work, but can fall flat when outcomes are measured holistically. Setting off in the wrong direction can have lasting consequences. It carries through design, into code, into test cases written against the same flawed assumption.

This is why building AI into software engineering is less about adding tools to existing workflows and more a wholescale reconsideration of the product development lifecycle.

Building narrow agents into the lifecycle

The most effective approach is to break the product development lifecycle into modular agents with narrow scope: one converts discovery material into structured requirements, another produces technical design, the other generates and runs test strategies. Narrow scope keeps each agent’s context manageable and its output consistent.

Importantly, this creates clear points of control. At each stage, AI proposes and progresses the work, while human roles review, challenge and approve before it moves forward. As a result, features can move from discovery to production-ready code far faster than before: design cycles compress, and test scripting that took four engineers can be handled by one, freeing up time for higher value work.

Those checkpoints matter because plausible output is the hardest kind to catch. Stack Overflow’s 2025 survey found 66% of developers name “AI solutions that are almost right, but not quite” as their single biggest frustration, and 45% say “debugging AI-generated code is more time-consuming.”

Without a review gate at each stage, that cost compounds rather than surfacing. GitClear’s  AI Code Quality research shows the trade-off more clearly: refactoring line moves are down 70%, and long-term legacy maintenance is down 74% versus 2022 levels, yet copy-paste, code block duplication and other indicators of technical debt continue to rise.

Governance calibrated to risk

None of this is safe without governance designed in from the first step and calibrated to risk. In practice, that means deploying agents in read-only mode before they are given authority to act. It means setting confidence thresholds before any routing decision is automated. This requires human sign-off on novel exception types even after an agent has proven reliable, and keeping a full audit trail across every decision point.

Much of the market is not there yet. The Cambridge Centre for Alternative Finance’s 2026 Global AI in Finance Services report found 78% of regulators rate explainability as critical or important to their objectives, while only around half of industry firms have adopted explainable AI methods. That gap illustrates how governance expectations continue to outpace implementation.

This discipline runs in two directions. We hold ourselves to it internally, in how we engineer, because anything we build for a regulated market has to survive that scrutiny first. It also must hold in the client’s environment: the firms we build for answer to regulators for every automated decision, so governance cannot be bolted on at the end – it needs be present at every step.

Clients in regulated markets need determinism and explainability. A system that runs end-to-end without a traceable, governed path is hard to put into production, however well it performs in a demo.

Measure the outcome, not the output

Counting volume is easy: more agents, more generated code, more automated steps feel like demonstrable progress. The metrics that matter include quality, real-world outcomes and cost to build.

One example: building connectors between Xceptor and third-party platforms through a conventional engineering process could take around two weeks. Running the same build through the AI-native product development lifecycle – agents generating requirements, design documentation, code and test strategies, with engineers reviewing and steering at each stage rather than producing from scratch – took two days. For clients, that difference means integrations stop being a bottleneck on go-live. Total cost to build also fell 83 per cent, including AI token spend.

Another example is the first agent we built for financial institutions, focused on extracting data from trade confirmations. Firms are often managing large volumes of confirmations which arrive in unstructured formats across document types, such as emails, PDFs and SWIFT messages – and extracting this data is where AI agents excel, delivering significant efficiency and accuracy gains.

From doing to directing

Building an AI-native product development lifecycle changes what engineering work looks like. As agents absorb repeatable execution, the human work concentrates on judgement: architecture, edge cases and steering output rather than generating it.

We found that after a short time, our engineers were no longer producing first drafts; they were reviewing and refining agent output. Sometimes they corrected the outputs, but more and more they were able to approve what was generated. The cognitive load moved from production to verification. This shift from making to directing and validating is the clearest sign of a maturing AI-native engineering model.

Eventually, we will think less as fixed teams and more as cells – product roles and builder roles working alongside AI, each person operating above the task they used to own. The role of a QA Engineer will shift towards creating the paved roads and guardrails that humans and agents use, enabling quality to be built in consistently across every cell.

It would be dishonest to frame this only as acceleration. When work you have done for years becomes something you direct rather than do, that is a real adjustment, and leaders who pretend otherwise may lose their best people to organizations that manage the transition better. Mandating tools is not the same as helping people use them well; in our experience it produces more licenses installed, not more work changed. Adoption comes from champions, role-specific playbooks and measuring delivery outcomes: a people-first approach rather than a procurement one.

None of this works without both sides. True AI-native product development depends on continual, close collaboration between humans and machines. Years of domain knowledge, paired with the speed and pattern-recognition of these systems, is what makes the outcomes better, not the technology on its own. That combination is what makes the process repeatable at scale.

OpenAI will stop AI coding platform Cursor from accessing its models from November 12, following the acquisition of Cursor parent Anysphere by Elon Musk‘s SpaceX.

“Today, we notified SpaceX that we intend to wind down our contract providing OpenAI models to Cursor, with a proposed shutoff date of November 12, 2026,” the company wrote in a blog post.

That shutoff, the company added, was based on its concerns that SpaceX will not use its technology in accordance with its terms of service, citing what it described as a history of Musk’s companies violating contracts: “After Musk acquired Twitter, now part of SpaceX, the company broke⁠ the terms of our contract (alongside many others). Under oath earlier this year, Musk admitted⁠ that xAI, now also part of SpaceX, had violated OpenAI’s terms of service (terms which are similar to xAI’s own),” the company wrote.

OpenAI and Musk remain locked in a broader legal dispute, with Musk having sued OpenAI over its transition from a nonprofit-controlled organization to a for-profit structure and OpenAI countering with allegations over Musk’s conduct and competing AI ventures.

Enterprises and developers using OpenAI models within Cursor now have about 10 weeks to transition to other AI models within Cursor, or choose a new coding platform.

Swapping problem

That may not be easy.

While the 10-week timeframe might be enough to assess the impact and decide a path forward, it will not be a trivial operation, said Abhishek Satapathy, principal analyst at Avasant.

Even for those just swapping models and staying with Cursor, there will be effort required to validate the replacement against development workflows currently running on OpenAI’s models, Satapathy said.

“This includes repository-level coding, debugging, refactoring, test case generation, multi-file changes and tasks where an agent has to inspect a codebase, make a sequence of changes, run tests and correct its own errors,” he said.

The need for validation stems from differences in how AI models handle coding, reasoning, tool use and instructions.

Developers may find that prompts or agent instructions that work well with OpenAI models produce different results with another model, requiring enterprises to retune prompts and evaluations, said Manoj Chandra Jha, principal analyst at Nord-IQ Research.

That recalibration could translate into a short-term productivity dip as development teams rework prompts and workflows and adjust to how the replacement model behaves, echoed Bhupendra Chopra, chief revenue officer at IT consulting firm Kanerika.

For enterprises considering a move away from Cursor, the transition becomes more complex, primarily because swapping coding platforms would require retraining developers, rebuilding integrations and agent configurations, and repeating security and governance reviews that not only require time but also adds costs, Satapathy said.

Broader risks of AI vendor dependence

The added complexity of changing platforms points to a broader issue for enterprises: their dependence on AI model providers and the commercial relationships that determine where those models can be used.

“Enterprises can no longer assume that a model available through an AI coding platform today will always remain available. Acquisitions, contracts, competition or regulation can change this,” said Pareekh Jain, principal analyst at Pareekh Consulting.

“Enterprises should therefore support multiple models, regularly test alternatives and avoid making important workflows too dependent on one model,” Jain added.

Similar principles should apply to the coding platforms as well, according to Satapathy.

“Enterprises should consider whether prompts, agent configurations, evaluation methods and tool integrations can be reused when the underlying model changes,” Satapathy said.

There are broader risks for the vendors too, especially OpenAI.

While Cursor appears better positioned to retain customers because enterprises can continue using the platform with other models, particularly with Anthropic’s pledged support, OpenAI risks losing developer usage as customers move to alternatives such as Claude without having to change their coding environment, Satapathy said.

This article first appeared on InfoWorld.

For many organizations, AI is proving easy to pilot but difficult to scale. Pilots often look inexpensive because they run on narrow datasets with a handful of users, explains Ben Schein, chief AI and analytics officer at cloud software company Domo. “But the cost lives in deployment, the moment you connect that capability to real workflows and the systems of record behind them,” he says. “That’s when the real bill appears.” So CIOs must always budget for the gap between when it works in a demo and when it produces governed and durable value.

Organizations can easily get caught out because they run pilots as a technology experiment instead of a business initiative, he adds. “The interesting question is never whether AI can do the thing in a demo,” he says. “It’s whether it should run in this process, and whether it survives contact with production.”

There’s also a lot of pressure on IT teams to be doing something with AI simply because everyone else is, says Naren Gangavarapu, chief transformation and AI officer at Australian Cruise Group.

He calls it AI theater because there’s a big show around AI even though there aren’t that many successful applications of the technology in production environments.

AI costs out of control

According to John D’Emic, CTO at AI observability platform Revenium, one of the big traps when running a pilot is failing to anticipate how quickly consumption can spiral as adoption grows. “As an example from our own engineering org, back in May, a developer opened an AI coding session on his laptop, and it stayed open for four days,” he says. “By the time it closed, it had run 4,819 calls and cost us $3,762. We didn’t budget for this, and no alert fired. But that one session cost more than a lot of teams spend on their entire monthly AI tooling.”

While this showcases how a developer can make a costly error, Dmitriy Anderson, CIO and digital and social commerce leader at home and gardening retailer Leroy Merlin South Africa, believes the pilot trap frequently happens when employees with little or no software development experience vibe code applications. “It doesn’t matter if you can create something in 15 or 20 minutes if the result is AI slop,” he says. “Think dirty code, no consideration for safety, security, and possible data exposure.” In most cases, these pilots are developed with one of the frontier apps, and someone probably used their personal AI subscription, so the costs are negligible, he adds. But if you have a company of several thousand people, and you now want to roll this tool out more broadly, that’s where costs can get out of control.

This scenario is only exacerbated by the introduction of agentic AI, D’Emic adds. “Agents don’t spend money at human speed,” he says. “In the old cloud days, an engineer could spin up infrastructure in minutes and finance might not see the bill for a month, which was painful but recoverable. Agents, though, call APIs around the clock without waiting on anyone’s approval.”

Mind the trap

While cost is a big factor in the AI pilot trap, it should be treated as a symptom of a bigger problem, says Schein. The underlying issue is governance and observability. “An autonomous workflow can fan out into more queries, API calls, and model invocations than anyone scoped,” he says. “So if you can’t see what it’s doing, and spend compounds quietly, you only find out once the invoice arrives.”

In a recent LinkedIn post, Anderson outlined how in just six weeks he built a platform for a fraction of the sticker cost using three AI models orchestrated together. The traditional estimate to build the same tool would have required 2,472 engineering hours from a team, and was expected to take around nine months. “I went through the proper engineering steps and planning, and made sure the application passed a series of cybersecurity frameworks,” he says. “The purpose of this exercise was to showcase that AI can still speed up the process even if you take the time to work through the necessary steps. You can build with AI rigorously and securely.”

So to turn AI experiments into enterprise value, every AI interaction must be attributable: who triggered it, against what data, on which model, and at what cost, Schein says. For each workload, be sure to ask how often it runs, which model tier the job actually needs, and what triggers it, human or automatic. “A frontier model on an automatic trigger and a small model called on demand are completely different cost curves for the same task,” Schein adds.

For Anderson, it’s helpful to use AI to highlight potential gaps, assumptions, or blind spots in your ideas early on. “When you start building an idea, ask the agent to interview you,” he says. “It will go through every phase and ask questions about the important facets of the process, from scalability and budget to deployment options. You can even make AI write a prompt for itself, because it knows its capabilities and quirks better than you ever will. It’s called meta prompting.”

Anil Inamdar, global head of data services for the Instaclustr BU at NetApp, suggests CIOs cost out the whole program, not just the demo. “Generally, the model itself is the cheapest part of the program,” he says. For him, it’s important to have security and governance people in the scoping meeting, not the launch meeting.

He believes the pilot trap is also, or perhaps mostly, a sequencing trap. “A lot of teams are wired to build first and ask permission later, only to discover months down the line they can’t pass a security review or data privacy audit without a painful and costly rebuild. It’s also valuable to define what failure looks like before you define success.

“Pilots tend to die because of no result, which isn’t the same as a bad result,” Inamdar says. “Emphasize to the deployment team on day one that if a target result by a certain month isn’t seen, we shut it down. Otherwise, you’re funding a zombie pilot because everyone’s invested and no one wants to be the one to call it out.”

IBM will embed OpenAI frontier models and products such as Codex and ChatGPT embedded into IBM’s AI consulting services platform, IBM Consulting Advantage, as well as expanding the companies’ existing collaboration in the cybersecurity realm, they announced Thursday.

Joint initiatives will include the creation of industry-specific products for financial services, government, telecommunications, and retail, as well as serving key enterprise domains such as finance, procurement, customer operations, and HR.

IBM will join the OpenAI Partner Network and engage forward-deployed engineers and consultants trained through the network to help clients accelerate their AI implementations. It will also create a dedicated OpenAI practice, certifying thousands of consultants and engineers via the Partner Network, it said.

There will be three focus areas in the new partnership: helping organizations transform their businesses to integrate AI into their daily work, assisting clients in modernizing legacy applications through a combination of OpenAI products and IBM’s expertise, and an expansion of an existing cybersecurity collaboration combining OpenAI frontier AI capabilities with IBM Autonomous Security.

Everyone, it seems, is engaging forward-deployed engineers to help enterprises build systems around their AI models: OpenAI announced its initiative, OpenAI Deployment Company, on May 11, a week after Anthropic launched its efforts. Microsoft and AWS too have jumped into the ring.

But, said Info-Tech Research Group distinguished analyst Mark Tauschek, “This is becoming table stakes. The consulting firms that have the horsepower and technical talent to partner with a frontier AI lab to do this are all picking their horses. Anthropic has some, Microsoft has some, and of course OpenAI has some. There will be more announcements like this to follow, and while it’s good PR for both IBM and OpenAI, it’s certainly not differentiating.”

Enterprises will choose the consulting firms that work with their AI vendor of choice, he noted, although he does think that Microsoft had the initial advantage because they were able to quickly provide thousands of skilled FDEs.

“But,” he said, “this is a horse race, and it’s going to be a tight one.”

One of AI vendor DeepSeek’s biggest selling points has been its ultra-low price point, but that party’s about to end.

The Chinese model provider is raising API pricing for its V4 model family by notable margins, in some cases by more than 1,100%. The increases may not be that dramatic for all, though; the company is encouraging “more flexible workload scheduling,” with peak rates and half-price off-peak rates.

The news was tucked into the announcement of the general availability (GA) of DeepSeek V4-Pro and upgrades to VR-Flash. The new pricing takes effect for most parts of the world on August 16.

“On paper, at peak, against the right comparator, DeepSeek’s price advantage does disappear, and in places inverts,” said Sanchit Vir Gogia, chief analyst at Greyhound Research. But in practice, “the schedule’s own clock and cache hand most of it back to any buyer paying attention.”

How Flash and Pro compare now

The new API pricing structure is as follows:

• Flash is now $0.22 per million input tokens (cache miss) and $0.66 per million output tokens off-peak; and $0.44 per million input tokens (cache miss) and $1.32 per million output tokens at peak.
  This is up from the flat rate of $0.14 for inputs (cache miss), representing a 57% to 214% increase, and $0.28 per million tokens for outputs, a 136% to 371% increase.
•  Pro is now $0.66 per million input tokens (cache miss) and $1.98 per million output tokens off-peak; and $1.32 per million input tokens (cache miss) and $3.96 per million output tokens at peak.
  This represents an input increase of between 51% and 203% (up from $0.435) and output increase between 127% and 355% (up from $0.87).

Inputs with cache hits, when apps reuse stored prompts rather than processing similar requests from scratch, have even more dramatic pricing increases of 52% to 1,100%.

Mark Tauschek, VP of research fellowships and distinguished analyst at Info-Tech Research Group, pointed out that the increase does eliminate the price advantage that 4.0 Flash has over OpenAI 5.6 Luna at peak pricing, but not at off-peak pricing, as OpenAI has dropped Luna API pricing by 80%, off-peak.

It also doesn’t eliminate Deepseek 4.0 Pro’s price advantage over Terra, OpenAI’s GPT-5.6 mid-tier reasoning model, even at peak pricing, nor its advantage over GPT-5.6 Sol released in July, Tauschek said.

Greyhound Research’s Gogia noted that, off-peak, V4 Flash is “marginally more expensive” on input and 45% cheaper on output than Luna. Pro at peak, meanwhile, runs close to 5x Luna’s price on a representative coding-agent workload.

DeepSeek’s roughly 98% cache-hit discount, against an industry norm nearer to 90%, is the mechanism that has kept its measured cost per task at about 60% below Luna, even after Luna’s cost cut, he said.

“The schedule re-prices exactly that mechanism,” Gogia said. Flash’s edge over Luna decreases from roughly sevenfold to threefold off-peak, and 1.4 times at peak. “The cache is where the advantage genuinely erodes.”

Encouraging users to rethink their schedules

DeepSeek’s V4-Pro is now generally available, and V4-Flash is in beta. Both models have new flexible reasoning capabilities (low, high, max) and ‘thinking modes’ that use chain-of-thought (CoT) reasoning to improve answer accuracy. V4 Pro is now available on app, web, and via API, and users can try it using “Expert Mode.” V4 Flash is now in beta.

The general availability “completes a two-tier structure in which Flash serves volume and Pro is priced for complexity,” Gogia noted.

DeepSeek’s peak/off-peak pricing is a means to “allocate resources more reasonably,” the company said, to encourage users to “schedule their tasks based on actual usage.”

Gogia pointed out that with the new model, 17 of every 24 hours stay at half price, so timing becomes an economic variable, and work that can wait moves into the cheap hours. In fact, the new pricing schedule hits DeepSeek’s home market hardest and its export market lightest; Western buyers largely pay the off-peak rates.

“Usage is following economics at least as much as capability, and economics can change by schedule,” Gogia noted.

Simple supply and demand

Reading between the lines provides a more nuanced picture, Tauschek noted. “While it’s alarming to see the headlines saying DeepSeek is raising API pricing by 50%-1100%, it doesn’t really tell the whole story.”

Part of that story is demand, which is increasing exponentially. DeepSeek can’t keep up with compute requirements, and Anthropic also had a price increase for the same reason in April. And, while third-party providers have not yet reflected that trend, they’ll eventually have to, Tauschek said.

“This isn’t unexpected at all,” he noted. “It’s simple supply and demand: when demand goes up, pricing goes up, because supply becomes constrained.”

For enterprises that do use DeepSeek (many in the US do not, or can not), the new pricing is not likely to change anything, he said. Cost increases will mostly impact developers, but it will still be less expensive than most alternatives.

He pointed out that enterprises are adapting to model routing, which is critical for developers using agentic workloads. Just a few months ago, organizations were paying per-seat pricing and running up usage as a matter of course, but the market move to usage-based pricing has resulted in sticker shock akin to that of the early cloud days.

“Pricing will continue to be a big deal because CFOs are starting to ask what they’re getting for the massive AI spend,” Tauschek said.

DeepSeek pricing doesn’t change the need for compatibility, multi-modality

CIOs should read the schedule with “relief and unease,” Gogia noted. Relief because the bill is largely schedulable; unease because “a supplier that has learned to price the clock has learned something about its own leverage.”

Going forward, he predicted, Flash keeps the volume usage, Pro handles complexity, and interface compatibility lowers the cost of adoption and departure. The real question becomes whether lower economic floors, open weights, and compatible interfaces, when taken together with multi-model routing, make foundation model intelligence materially easier to substitute.

Capable inference can be produced “far below the price structures that once surrounded frontier AI,” Gogia noted, and open weights mean model developers become one of just several parties able to serve inference requirements. “The traditional software dependency changes shape when that happens,” he said.

The vendor still matters, as do capability and support, but once a workload can move between providers, and enterprises manage their own orchestration and governance, the vendor no longer owns the whole dependency, Gogia said.

The most lasting effect of DeepSeek is unlikely to be that it stayed cheapest, he noted. “It is that every provider must now explain why intelligence should command a premium once near-equivalent capability is available through several technical and commercial routes.”

This article originally appeared on InfoWorld.

Software companies building AI capabilities into existing products are coming up against a pretty big problem: Customers just aren’t that interested.

Fifty-one percent of software makers that have added AI to existing products report that less than a quarter of customers actually use the new features, according to a recent survey conducted by software vendor acquisition firm Banyan Software.

This “deployment gap” comes from a lack of planning and measurement to target what AI features customers would use, the company claims in a report on the survey.

“Plenty of operators moved fast and blind, and that is exactly how you end up with AI no one uses,” the report says. “The ones who pulled ahead moved sooner than felt comfortable, and watched what happened closely enough to know what was working.”

According to Banyan, software makers should put one person in charge of expanding AI features in their products and measure the uptake from customers.

“Wire AI to results you can show, so your board, your team, and a future buyer can see it without you in the room explaining,” the report says.

The same goes for CIOs looking to thread new AI functionality into customer- and employee-facing apps and services.

Features the customers don’t need

Daniel Wilson Kemp, co-founder and CEO of payments and point-of-sale software vendor Lifted Holdings, agrees that many software vendors seem to be building AI capabilities that customers either don’t value or don’t understand.

“Users do not wake up wanting to use AI,” he says. “They want to close the books, answer a customer, resolve an exception, or finish a shift faster. If the AI is a separate destination, requires a new prompt habit, or returns an answer without the context and permissions of the system of record, usage will stay low.”

The problem is more of a workflow issue than an adoption one, Kemp suggests.

“The most important adoption test is whether the AI owns a useful step in an existing workflow,” he says. “AI adoption rises when the feature disappears into the job. If users have to leave the workflow to go use AI, the deployment is already asking too much.”

Kemp doesn’t see the low adoption rate as resistance to AI itself, but related to concerns about unclear value, bad UX, weak domain context, potential errors, and pricing that crop up before customers see measurable benefits.

“Vendors can charge more when the capability reliably saves labor or reduces risk, but an AI surcharge for a generic chat box is difficult to defend,” Kemp says.

Adding AI to a software product doesn’t guarantee it’s useful, adds Darren Kimura, CEO and president of agentic AI infrastructure provider AISquared.

“The reality is that the software industry has become very good at putting an AI button into a product and calling that product AI-native,” he says. “That is not the same as building AI into a product and using that in production.”

Enterprise AI has what Kimura calls a “last-mile” problem. Adoption breaks down when the AI reaches the real operating environment, and companies need to consider cybersecurity, usability, and end-user adoption, he says.

Customers generally aren’t reluctant to use AI, he says, but they’re reluctant to deploy tools they can’t control or understand.

“In my experience, organizations rarely need more AI features,” Kimura says. “They need the controls, integrations, and operating model required to use the features they already have.”

Some AI add-on tools also have integration problems, he adds. “AI that sits next to the workflow becomes a demonstration,” he says. “AI embedded inside the workflow becomes infrastructure.”

Kimura sees a major disconnect between what vendors build and what employees actually need. Employees want to process a claim faster, detect fraud earlier, resolve a supply-chain issue, or eliminate hours of repetitive analysis.

“Employees generally do not wake up asking for another chatbot,” he says. “They adopt it because it removes friction from work they already perform.”

The same warnings and caveats pertain to in-house AI development efforts or attempts by IT leaders to force-feed software makers’ new AI features into company workflows.

Confused customers

Customer confusion plays a big role in slow AI adoption, adds Sofia Barbosa, chief customer officer at BMC Software.

“Customers aren’t reluctant; they’re often overwhelmed,” she says. “They want to use it, but they’re being inundated with vendor messaging about new AI capabilities and how to use them, and it’s hard to know what to prioritize.”

Customers must decide whether to build or buy new AI tools, or use the vendor tools they already have, all while training their teams and anticipating future pricing changes, Barbosa suggests. “That’s a lot to sort through, and it slows adoption down even when the capability itself is ready,” she adds.

Software vendors need to aim to embed AI into their products in a way that feels effortless, is part of the operating model that customers already use, and intuitive enough that early adoption doesn’t require a big lift, Barbosa says.

But that’s only half the battle. Vendors also need to back their AI tools with structured, scaled adoption models that tie directly back to value realization and ROI, she adds. “Capability without that structure is where the gap shows up,” she says.

Investor appetite for the burgeoning vibe-coding startup ecosystem has shown few signs of satiation over the past year plus, with Swedish AI upstart Lovable’s Series C injection at a $13.3B valuation the latest evidence of a sector viewed by venture capitalists as one of AI’s most promising business disruptors.

AI-assisted coding has proved to be AI’s most compelling — and commercially viable — enterprise use case to date. Developer-aimed tools such as Cursor, which sold to SpaceX in June for $60B, and Windsurf, which last year entered a $3B OpenAI dalliance before its eventual talent flight to Google DeepMind for $2.4B, have become — along with Anthropic’s Claude Code — well established in enterprise arsenals for accelerating developer output.

But another set of vibe-coding tools, represented by the likes of Lovable and Replit, which hit a $9B valuation in March, seeks to ride the same path into the enterprise that no-code/low-code tools did previously: through your business users. These tools are built to democratize application development, giving users an AI chat interface to converse their way to enterprise-ready prototypes with fairly polished UIs, as CIO.com’s Peter Wayner writes in his roundup of the leading tools the space.

Some IT leaders are already enlisting business users to vibe-code their own apps. Scott Weller, CTO at financial services technology provider EnFi, in May told CIO.com’s Bob Violino, “The results have surprised us. What started as an engineering productivity initiative has become a company-wide capability, where anyone from the CEO to a customer success manager can turn an idea into a working prototype in hours, not weeks.”

For Weller and other early movers, vibe-coding tools are changing who participates in building a product. In some cases, this has translated to shortened product completion timelines and winnowed down IT to-do lists; in others, it is helping to foster culture change.

“When people are learning and applying AI to solve a real business problem, it creates purpose and momentum,” CIO Oral Daly told Violino of training services provider Skillsoft’s expansion of vibe coding beyond development teams.

“It helps people move from seeing AI as something abstract or intimidating to something they can work with thoughtfully, using judgment and collaboration rather than relying on rigid processes,” she added. “The solutions created as a result of vibe coding have filled capability gaps and delivered solutions to production in shorter timeframes, producing real value.”

As with previous iterations of the no-code paradigm, CIOs embracing vibe coding across the enterprise face their own set of challenges. Maintaining quality, for one. Governance — access controls, identity management, data handling — is another big one, familiar to CIOs. As is security, given concerns about AI’s ability to create secure code.

Plus, as with all things AI, organizational issues are compounded when vibe coding is unleashed across the enterprise.

“Most companies, including ours, are still learning where work actually happens versus where they think it happens,” Noe Ramos, vice president of AI operations at Agiloft, told Violino. “Before you can extend AI into a business function, you have to understand the real workflow, not the documented one. That discovery work is underestimated almost everywhere.”

All told, vibe coding enterprise apps remains tricky business, as CIO.com’s Grant Gross writes. And CIOs should beware business users falling prey to the “seduction phase,” Geoff Burke, senior technology advisor at ransomware defense vendor Object First, told Gross.

“At first, it feels like a brilliant partner,” he explained. “But give it too much autonomy and it injects inaccuracies, complexity, and bypasses security norms, which you will spend twice as long cleaning up later.”

A Replit coding agent, for example, deleted a company’s live production database. So CIOs need to wade cautiously into the vibe-coding waters.

But the promise is there. Creating software and web applications using everyday language is a powerful — and, from the business users’ perspective, empowering — proposition. And startup PR and sales literature bills itself as more than a prototype-maker. The consumer space results may be considerable and point to a promising future, but expansion into business environments requires a considerable elevation in trust.

In the meantime, IT leaders should be prepared for further hype in this area. In addition to the valuations and acquisitions mentioned, Indian AI coding upstart Emergent became a $1.5B unicorn in July, Bolt is nearing the $1B plateau, and former GitLab CEO Sid Sijbrandij has thrown his hat into the ring with Kilo.

All that money points to investors having enterprises in their sights. Beyond a liquidity event, the best way for many of these platforms to make good on ever-escalating cash injections will be to gain a foothold in business. CIOs should be prepared for business users to not only be exploring these tools but also fielding sales calls about them. After all, as Lovable notes in its press materials, its no-code AI tool has already reached employees at nearly two-thirds of the Fortune 500.

To date, though, vibe coding remains a crowded market, one that has Harvard Business School professor David Yoffie advising said startups to sell now, given that many face competition from the frontier labs that act as their suppliers as well — and that are poised to cash in big with pending IPOs of their own.

That adds extra noise to CIOs’ decisions in this space. Governance and security are the chief concerns when it comes to selecting and implementing these tools, but IT leaders can’t shortchange questions around long-term viability when it comes to placing their platform bets.

More than anything, CIOs need to address the viability of vibe coding for their business, and not just to keep ahead of the usual shadow IT cycle. As we’ve seen with previous business technology paradigm shifts, vibe coding — along with AI-related initiatives in general — holds the potential to destabilize IT leaders’ standing within the C-suite and organization at large.

CEOs are anxious for AI advancement, and headline valuations for vibe-coding startups draws attention to — and fear about — the business ramifications and opportunities of potential disruptors in the eyes of business execs. That can create an atmosphere of anxiety and opportunism. But CIOs’ hard work in navigating their organizations through the pandemic, aligning their IT strategies to business value, and setting the course for AI ROI have them positioned well to help shape a possible vibe-coding future for their organization’s business functions, even if it means the new technology purchase lands on a business colleague’s ledger.

Disclosure: One of Lovable’s new Series C investors is Regent, the investment firm that also owns CIO.com parent company Foundry.

“We’re generating more code than ever. My senior engineers are drowning in review,” a VP of engineering at a mid-sized software company told me.

I hear this from engineering leaders almost every week. AI was supposed to fix delivery, but it just moved the bottleneck.

If you feel the same way, you’re neither wrong nor alone: in CloudBees’ 2026 State of Code Abundance report, 81% of enterprise technology leaders reported a rise in production issues tied to AI-generated code, while 92% said they were confident the code was production-ready before it shipped. That gap between confidence and production reality is the warning. We spent two years putting AI assistants in front of every developer and almost none rebuilding the workflow behind them.

The bottleneck has moved

When a company is dropping GitHub Copilot or Cursor into the existing lifecycle and waiting for speed, have no doubts they are treating AI as a productivity patch. And it won’t last long.

Before AI coding tools, companies struggled to get enough good code. But today they create more code than ever before. GitHub’s Octoverse 2025 reported 43.2 million pull requests merged per month, up 23% year over year. Today, the bottleneck is deciding what code should be merged or redesigned, and what risk is slipping into production.

You improve delivery throughput, but degrade delivery stability through AI adoption. Since AI-authored changes are larger, touching more files per diff, each review decision carries more uncertainty and, therefore, more risk. Simply speaking, you ship faster and also break more.

The review quality drops when senior engineers skim 400-line diffs, focusing on style. They lose focus on the vital security and correctness questions.

Treat AI as a coding patch, and your best engineers end up spending Fridays reviewing diffs instead of designing systems. You can’t afford not to rebuild the underlying operating model.

How to rebuild code review for the AI-native era

The trust developers are ready to give AI has dropped from 40% a year earlier to 29%, according to Stack Overflow’s 2025 Developer Survey. 66% of them describe AI output as “almost right, but not quite.” In review terms, “almost right” means dangerous.

For example, take a pull request for a discount feature. From a technical perspective, the pull request builds a discount endpoint, validates the input, returns clean JSON and passes the unit tests the AI agent wrote for it.

But the logic applies the discount before the eligibility check, not after, reversing the rule in the ticket. In other words, the system gives discounts to customers who should not receive them.

Why would that happen? Companies are used to relying on a single reviewer, human or AI, to answer every question, even when those questions carry different levels of risk. But code review is no longer a single job, and mixing all review questions in a single task creates noise and more “almost right” output.

The answer is in splitting the review job.

How to split review

You need a single connected review process with clear roles. One coordinator agent finds every open pull request linked to a ticket and pulls the right context for review. Two AI review checks run inside the same process.

The first agent checks requirements, running once across all related pull requests, reading the ticket’s solution notes and acceptance criteria. It asks only one question: did we build what was asked?

The second checks quality, running on each pull request in parallel and looking for critical issues, including security, error handling, architecture and missing or stale tests. It uses best-practice rules for that specific service type before the review runs.

Their findings merge into one consolidated comment on the ticket, sorted into “requirements” and “quality.” A human reviewer can see instantly whether the issue is about scope or code quality.

Human engineers do not leave the loop. They still define what “critical” means for a given stack, tune the rules when the same violation keeps recurring and, importantly, own the merge decision on any high-blast-radius change. They decide what to ship when a mistake could cause severe damage.

What the review model needs to work

The agent needs something concrete to check against. Before an AI agent reviews anything, it needs an explanation of the type of service it is looking at and a precise request in the ticket. You will need a catalog that maps each repo to its service type and architect-written solution notes for each ticket, including contracts, schema details and also scope limits.

In early pilots, review agents flagged old problems in untouched code. While some comments were technically right, they were useless. When you scope every finding to the lines that the change actually touched, you could avoid such behavior.

The more autonomy you give AI, the more boundaries you have to set. “AI review” can mean different levels of AI responsibility, and the governance question changes at each step. Yet, on any high-blast-radius path, that last step stays human — full stop. 

Don’t give AI more freedom just because the pilot looks good on a slide. Give it more freedom only when the results prove it’s safe and useful. In the pilots I’ve run, agent findings start with an acceptance rate around 35-40% and climb past 60% as context improves. Even that early number matters. It means the agent is catching real issues instead of parroting the linter. But acceptance rate alone isn’t enough to justify expanding scope. I only expand scope when acceptance rate is climbing and the post-merge defect rate is holding flat or falling. One signal moving without the other is a red flag. 

I keep telling technology leaders to let AI handle routine checks and keep senior engineers focused on the risky merge decisions, unless they are ready to pay it back in incidents.

The human side of AI-assisted review

In an AI-native environment, senior engineers become verification strategists. But you should expect resistance. Teams don’t trust AI enough, and they also resist changing their review habits. Once teams break free from the gravity of old habits, senior engineers start getting genuine capacity back and spend it on architecture and risk instead of line-by-line code review.

The same pattern—stop doing the repetitive verification and start designing it—repeats itself in QA. Teams move from re-running obvious checks to validation design, deciding what must run in a sandbox, what stays human-only and what evidence belongs in the audit trail.

Sometimes AI review takes root fast, sometimes harder. Small teams adopt it quickly on greenfield work with a modern stack and fast feedback. Unlike the brownfield work, where you face legacy services, complex frontends and years of tribal knowledge. There, one incident is enough to convince the team that AI review won’t work.

You should always start by piloting a real feature and see which AI findings engineers accept and which defects appear after the merge. You will use the findings later to add meaningful guardrails and extend AI-assisted review to more services.

Companies should split the review job before CloudBees’ 81% becomes a number on the quarterly slide. Without that change, they will be impressively good at shipping code they never fully check.

Open the history tab of any epic that has been alive for more than two quarters. Go ahead, pick one. Count the edits. Somewhere around edit 11, the description was rewritten to satisfy a stakeholder who has since changed roles. Around edit 19, the scope was trimmed to protect a date that, in the end, moved anyway. By edit 26 someone renamed the whole thing, and the sentence that explained why the work existed in the first place didn’t survive the paste. 26 edits, several hundred hours of delivery behind them, and nobody left who can say what the money was for.

Nobody deleted that reason on purpose. That’s what makes this so hard to see.

I’ve been shuttling between the people who fund technology work and the teams who deliver it for a couple of decades now, and something has always struck me as odd: the backlog is probably the only important document in the enterprise that gets edited every day and remembers nothing. Contracts have version control and signatures. Financial statements have audit trails. Even architecture, in mature shops, has decision records. But the artifact that actually steers what hundreds of people build week after week? It has a title, a status and a description that mutates until the original intent becomes archaeology.

The most expensive failures I’ve seen were all fast. The teams shipped and shipped, and somewhere along the way the work stopped meaning what everyone assumed it still meant. Nobody slowed down long enough to notice.

One problem, two lenses

Strategy and delivery look at the same work through very different mental models. On one side, leaders talk in outcomes, intent and value; they worry about whether the original justification for the investment still holds months later. On the other side, teams think in iterations, flow and momentum, and they worry about keeping complex programs moving in small, manageable steps. Both lenses are legitimate, and in my experience both sides generally believe they’re the ones doing everything right.

The disagreement between them is never loud. Strategy quietly assumes the logic will remain constant across every sprint and every decision. Delivery quietly assumes the strategic reasoning will naturally update itself based on what gets learned along the way. There’s nothing wrong with either assumption on its own. But in the absence of a structural bridge between them, every program gradually accumulates small half-measures and shifted meanings that nobody registers until it’s too late.

The evidence on how badly intent travels is humbling. Donald Sull and his colleagues, in a multi-year study of strategy execution, found that only half of middle managers can name any of their company’s top five priorities. Those are the managers. Now imagine the epic, eleven edits later.

Let me be fair to agile here, because agile is not the villain. It does exactly what it says on the tin: it helps teams learn quickly and adjust to what they discover, and that speed is a genuine strength. The problem is that organizations blur the line between two kinds of change. Some of it is genuine learning: teams discover real behaviors, markets shift, leaders sharpen their thinking. And some of it is erosion, the slow loss of rationale that nobody actually decided and nobody can trace back to a witting choice. From the outside, the two are indistinguishable. They show up the same way in the tooling: movement in the backlog, shifting priorities, even working software. Only one of them stays anchored to the reason the money was spent.

Most organizations have no instrument for telling these two apart. Which means they’re flying at full speed without knowing whether they’re navigating or just moving.

The pattern we keep seeing

Agile in style, not in substance

The board gets moved every day, stand-ups start on time and retrospectives produce long lists of things to improve. Then you ask why a specific feature exists, what it’s actually meant to change, and the room gets quiet. The rituals persist while the substance underneath them slowly thins out. Teams keep closing tasks, and somewhere along the way they shed the shared sense of purpose that made the tasks worth doing.

Velocity becomes a proxy for value

A smooth sprint demo can hide a deeper problem, because progress toward delivery and progress toward outcomes are two different measurements, and only one of them is on the wall. I’ve seen features that were stable, polished and warmly received in the demo, and that contributed absolutely nothing to the decision they were supposed to improve. The pace was real enough; whether any of it mattered took months to find out. And your delivery metrics can be excellent, genuinely excellent, while every one of these patterns is running underneath them.

This is not a niche affliction, by the way. Pendo analyzed feature usage across hundreds of software products and found that 80% of features are rarely or never used. Built at full velocity, shipped into silence.

Product owners absorb pressure instead of defending logic

The PO is supposed to hold the thread, to protect the reasoning behind the work when everyone else is pushing on it. In practice, many find themselves wedged between demand and delivery, forced into a permanent state of reactive prioritization. Over time they stop challenging requests. Then they stop defending the logic behind decisions. Eventually they stop framing choices around outcomes at all, and the backlog, which should be a strategic instrument, turns into the place where everything gets dumped because nobody has the space left to ask what actually belongs there.

Backlog churn masks strategic drift

Items get revisited, split, recast and reprioritized as everyone works to keep momentum going, and from a distance it can all look like reasonable adaptation. But when the connection to intent is severed, all that motion begins to dissolve into static. Work keeps getting passed around, the board stays busy and the program veers off course without producing a single alarming signal, because busy is what everyone was looking for.

Every quarter is a reset

New OKRs arrive. A fresh wave of leadership messaging follows. Sometimes the team gets reshuffled too. With each round, a little of the shared context that held everything together quietly slips away. Epics get new names, stories get rewritten, priorities rearrange themselves almost by accident. The organization keeps rebooting itself without ever asking what it left behind in the reset.

Taken one at a time, each of these patterns is understandable, even forgivable. Together they produce a program that looks healthy from every angle while it quietly hollows out the meaning behind the work.

Why this keeps happening, and why it’s about to get worse

Big programs tend to assume that intent will simply carry itself forward as the work passes through teams, decisions and iterations. It won’t. Intent doesn’t carry itself. If nobody actively preserves and updates the reasoning, it starts to loosen and fray, quietly and almost politely, one story, one trade-off, one shift in priority at a time.

The structural cause is a speed mismatch that most governance was never designed for. The delivery system evolves in hours; the organization’s memory of why updates in quarters, if at all. In between those two clocks, thousands of micro-decisions reshape what the work means, far faster than anyone captures the reasoning behind them.

Now add what’s happening in 2026. AI agents inside the delivery tooling can already organize, create and edit backlog items on a team’s behalf. Atlassian’s own customers describe agents that generate requirements, break them into epics and stories and take delegated work like a teammate, and these capabilities now ship inside the standard Jira plans that most enterprises already pay for. I’m not against any of this; some of it is genuinely useful. But notice what it means for our problem. Every one of those operations is an edit to a document that has no memory. Backlog amnesia at human speed was survivable. Painful, but survivable, because humans forget slowly. Amnesia at machine speed is a different animal altogether. The ratio of motion to memory, already unhealthy in most organizations, is about to go vertical.

If your backlog can’t remember why an item exists after a human rewrote it a few times, think about what happens when an agent grooms it continuously.

What to do about it

The countermeasures I use are deliberately small. None of them adds a ceremony, a tool, or a governance layer. They simply orient the practices teams already run toward one job: keeping the reasoning alive while the work moves. Together, they form the discipline I call Structural Agile.

• Start with the outcome. Before an epic or major story enters the backlog, three questions, every time: What behavior are we trying to shift? How will we know if that behavior changes? What signals will confirm success after release? If the room can’t answer, the work waits, because items that lack outcome clarity tend to drift first and drift fastest.
• Elevate the PO. Position the product owner as the carrier of outcome logic, with an explicit mandate to preserve rationale, flag trade-offs that erode intent and track deferred items together with the reasoning behind them. And be realistic about the limits, because many POs inherit chaotic backlogs, rotate mid-stream, or simply lack the authority to push back on stakeholders. The rule I give teams is simple: if the PO can’t carry the logic, someone must: a coach prompting context checks, an architect recording the reasoning behind technical trade-offs, an analyst keeping the outcome picture current. Build logic stewardship into the structure. Left to personality, it leaves with the person.
• Anchor epics to why. Every epic carries its rationale as metadata, inside the tool where the work actually lives. Slide decks from last spring don’t count. When a decision reshapes the epic, the rationale gets updated in the same motion; waivers and scope cuts get recorded next to the item they changed. Do this consistently and the backlog stops being a queue of tasks and becomes a living map of intent, one that a new joiner can read on day one, and that survives a challenge from leadership without anyone having to reconstruct history from memory. It cuts both ways, too: the same rationale that protects the team from whiplash protects the business from a backlog that has drifted away from what they actually asked for. Prioritization turns into a conversation about evidence rather than a contest of opinions.
• Rehearse erosion. This is the practice I’d start with, and the one that surprises teams most. Every two or three sprints, run a short, structured session that is not a retrospective and not a risk review. Its purpose is to test the continuity of intent itself: Does the assumed user behavior still make sense? Where might adoption fail even though delivery is technically correct? Which parts of the outcome logic feel fragile, outdated, or untested? A retro examines how the team worked; an erosion rehearsal examines whether the reasoning still holds. You rehearse erosion the same way pilots rehearse emergencies: you hope the drill is wasted, and you run it anyway, because catching drift early is what makes fixing it cheap. In my experience, a single one of these sessions surfaces more strategic risk than a quarter’s worth of status reporting, and it costs the team about half an hour.
• Keep the logic alive. Capture only what prevents strategic amnesia and nothing more: why a feature was removed or reshaped, who approved it and which assumptions should be revisited, and when. Keep it visible where teams already work. If logic lives in Confluence but dies in conversation, it’s already gone.

Start Monday

You don’t need a reorganization or a new framework to begin, and frankly you shouldn’t want one. Three entry points, close to zero overhead. Assign a critical reviewer: one team member whose standing job is to periodically ask whether stories still connect to the intended outcome. Add a one-minute outcome check before major refinements: the behavior targeted, the indicator watched, the signal expected. And run a single erosion rehearsal on your most important program; teams usually surface something real in the first session, long before it would have shown up in any metric.

For readers keeping score: yes, neighboring practices exist, and they’re good ones. Architecture decision records preserve the why behind technical choices, and impact mapping connects deliverables to goals at planning time. I use both. Neither operates continuously, inside the backlog, at the level of the individual item, which happens to be exactly where the forgetting occurs. OKRs don’t solve it either; objectives at altitude are necessary, but teams still need the rationale embedded in the work itself, so they don’t have to keep a separate decoder.

The history tab, revisited

Go back to that epic with the twenty-six edits, and imagine the same history with one difference: each consequential edit carries a line of reasoning, current and human-readable, and every few sprints someone deliberately tested whether that reasoning still held. Same team, same velocity, same tool and a completely different answer when someone finally asks why the work exists.

Velocity tells you how fast the work is moving. Only memory can tell you whether anyone still knows where it’s going.

I’ve published the full discipline behind this approach (the five principles, the roles, the facilitation guides and the objections seasoned practitioners will raise, along with my answers) as a featured paper in PM World Journal. The mechanics are free to steal. The forgetting, at this point, is optional.

A few weeks ago, I found myself in yet another demonstration of an application that was not built by my team or my technology partners. The demonstration lasted 20 minutes and by the end of it, everyone in the room agreed that the application solved a genuine business problem. There was genuine admiration for the business team’s initiative, a few questions about future enhancements and the inevitable congratulations that accompany any successful AI story. Then somebody asked, almost casually, “Can IT roll this out quickly across the organization?” It was a short question that unfortunately needed a long and unpopular answer.

I am sure almost every technology leader reading this has experienced some variation of this moment. The application itself is rarely the problem. In fact, many of the applications I’ve seen over the past year have been remarkably good. What concerns me most is something rather different. Somewhere along the way, we’ve started confusing the act of building software with the responsibility of running it. AI has dramatically reduced the effort required to create an application, but it has done little to reduce the effort required to own and operate one sustainably.

That distinction may sound subtle, but it is not. I think this might be one of the most significant leadership challenges of the AI era.

The success nobody planned for

None of this should come as a surprise. For years, we have been telling the business to become more digitally savvy. We invested in low-code platforms and citizen development initiatives, organised hackathons and innovation challenges, and repeatedly argued that technology shouldn’t become a bottleneck to solving business problems. The rapid emergence of AI coding assistants has simply completed that journey. Today, anybody from finance, marketing or operations can turn an idea into a working application faster than most technology teams can schedule a requirements workshop.

Personally, I think that’s amazing. Some of the most interesting ideas I’ve seen this year didn’t emerge from tech teams. They came from people who understood the business problem intimately and no longer needed permission to begin experimenting. That’s a future I would much rather embrace than resist.

The problem isn’t that business teams are building software. The problem is that successful prototypes have a habit of raising enterprise expectations quickly. Yesterday it was a departmental experiment. Today it is being demonstrated to the executive committee. Tomorrow someone is asking why the rest of the organization isn’t using it. The application hasn’t changed; the expectation has. In many ways, this feels like the next evolution of what we’ve traditionally called shadow IT. The difference is that these applications are often better engineered, solve genuine business problems and, ironically, are being built with the very experimentation that technology leaders have spent years encouraging.

The thin line between building and running

This is the point where discussions between business leaders and technology leaders begin to fall apart. The business sees an application that works. Technology sees an application that now needs to survive outside the protected environment in which it was created. Those are fundamentally different things.

A prototype rarely worries about things like identity management, resilience, audit trails, backup policies, API versioning, support models or regulatory obligations because none of those questions matter while an idea is still being tested. However, they become important once the organization decides that the application has graduated from an experiment to an enterprise capability. In many ways, this is the point where software engineering gives way to software operations—a discipline that organizations like Google have spent years formalising through practices such as Site Reliability Engineering (SRE).

This is the point where many organizations are beginning to underestimate the challenge. AI has democratised software development. It has not democratised enterprise operations. Running software is an entirely different discipline. It is less visible, less celebrated and considerably less exciting than building it, but it is also the reason enterprise technology exists. Every application that enters production quietly accumulates obligations. Someone has to secure it. Someone has to integrate it. Someone has to monitor it, patch it, support it and explain it to an auditor. Eventually, someone has to retire it. None of those responsibilities disappear simply because the first version happened to be created in forty-eight hours using an AI.

Walking the tightrope

The temptation for technology functions is to respond in one of two ways. The first is to become the organization’s brake pedal. Every application must now navigate governance committees, architecture reviews, security assessments and operational checklists before it is allowed anywhere near production. The enterprise is undoubtedly safer, but enthusiasm evaporates quickly when innovation feels like it needs intricate planning and convoluted permissions.

The second temptation is more subtle, and in many ways more dangerous. We become so determined not to discourage innovation that every successful prototype quietly becomes another production application. We congratulate ourselves on enabling the business while gradually accumulating a software estate that nobody really owns or understands. Six months later, the original creator has moved to another project, the AI prompts have disappeared, users have doubled, integrations have multiplied and suddenly the technology team is required to support something it neither designed nor approved.

Neither extreme is sustainable.

This, I suspect, is the balancing act that leadership will increasingly be judged on. Not whether we can prevent people from building software—that battle has already been lost, and rightly so—but whether we can encourage experimentation without allowing enthusiasm to become tomorrow’s operational burden.

I’ve discovered that the tone of these conversations changes entirely if we begin with curiosity instead of governance. Rather than asking why technology wasn’t involved earlier, we now ask what problem the team was trying to solve. It sounds like a small change, but it transforms the discussion. People become far more willing to talk about security, resilience and operational ownership once they know those questions are intended to preserve what they’ve built rather than prevent it from succeeding.

Stewardship, not gatekeeping

Interestingly, this isn’t simply a challenge that individual technology leaders are experiencing. Recent research points in the same direction. The 2025 DORA State of AI-assisted Software Development report concludes that AI acts primarily as an amplifier. It magnifies the strengths of organizations with mature engineering practices and exposes the weaknesses of those without them. In other words, the greatest returns from AI don’t come from the coding tools themselves, but from the quality of the underlying engineering and operational system.

Gartner arrives at a similar conclusion from a different perspective. In its analysis of enterprise AI coding agents, the firm argues that the market is rapidly evolving beyond developer productivity towards operational excellence and enterprise readiness. As organizations begin operationalising AI-generated software at scale, governance, operational ownership and long-term lifecycle considerations become just as important as the tools themselves.

None of this should really surprise us. We’ve spent the last couple of years asking whether AI can help us build software faster. That question has largely been answered. The more interesting question now is whether organizations are prepared for the consequences of making software creation almost frictionless. Every successful application creates an obligation that lasts far longer than the weekend it took to build.

Technology leaders have traditionally thought about technical debt as ageing platforms, deferred upgrades, architectural compromises and code that has outlived its original design. CIO.com has written extensively about the long-term business impact of technical debt. I believe AI is quietly introducing another form of debt that deserves equal attention—operational debt.

Operational debt begins the moment an application is promoted from a successful prototype to a business-critical service without a clearly defined operating model. Every application that is enthusiastically pushed into production quietly becomes another long-term obligation. It needs monitoring, support, ownership, governance, funding, documentation and, eventually, retirement. Unlike technical debt, operational debt is rarely visible until something fails, an audit raises uncomfortable questions or the person who originally built the application has long since moved on.

The role of leaders may no longer be to decide who gets to write software. AI has already democratised that capability. Our responsibility is something altogether more nuanced. We have to preserve the excitement, curiosity and initiative that AI has unlocked across the business while ensuring that the enterprise remains secure, resilient and supportable. Push too hard and we become the one that quietly kills innovation. Push too little and we inherit an estate of applications that nobody is truly prepared to operate.

This isn’t a governance problem. It’s a leadership one…and I suspect it may well become one of the most defining responsibilities of enterprise technology for years to come.

This article is published as part of the Foundry Expert Contributor Network.
Want to join?

Forward-deployed engineering (FDE), has moved from being a niche delivery model to becoming one of the most important operating patterns for enterprise artificial intelligence. In traditional software programs, organizations could usually separate product engineering, implementation consulting, operations and governance into different teams. Agentic AI changes that separation. An agent does not merely answer a question; it may plan, call tools, read enterprise data, update systems, create artifacts, trigger approvals and continue across several steps. Because of this, production success depends less on a model demo and more on the careful engineering of business context, workflow boundaries, controls, observability and human accountability.

FDE addresses this gap by embedding engineering capability close to the business problem. A forward-deployed engineer works with product teams, domain experts, security teams, platform owners and end users to convert an AI idea into a working, governed, measurable system. The role combines software engineering, data engineering, cloud architecture, model evaluation, security design, user research and operational ownership. In the Agentic AI world, this blend is not optional. It is the difference between a clever prototype and a dependable production workflow.

Why FDE is needed in agentic AI

Agentic AI deployment is rarely a simple matter of selecting a foundation model and connecting it to a user interface. Enterprise agents operate inside business processes that already contain policies, data quality issues, exception paths, audit requirements, identity controls and legacy systems. A sales operations agent, for example, may need to read CRM records, interpret account notes, generate a renewal recommendation, check discount eligibility, route an approval and update the opportunity. Each of those steps introduces risk. The agent must know what it is allowed to do, what it should never do, when it must ask a human and how its decisions can be traced later.

This is where FDE becomes valuable. FDE teams do not treat Agentic AI as a packaged tool to be installed. They treat it as a socio-technical system that must be shaped around a real business workflow. They discover the actual process, map data dependencies, identify integration points, define controls, implement the orchestration, create evaluation suites and help the client team learn how to operate the system after the initial deployment. The forward-deployed model is therefore especially suited to the last mile of AI adoption, where most enterprise AI initiatives struggle. This view is consistent with Gartner’s guidance that enterprise AI agent success depends on proportional governance aligned to autonomy level and scope of access.

The FDE operating model

A mature FDE operating model normally follows a compressed but disciplined cycle. The team first clarifies the business outcome rather than accepting the initial solution request at face value. Next, it decomposes the workflow into tasks, decisions, systems, data sources and approval points. It then builds a thin production slice rather than a detached proof of concept. This slice includes real authentication, realistic data, monitored tool calls, repeatable tests and rollback options. Once the system is usable, the FDE team iterates with business users, tunes the agent behavior, improves the prompts or policies, hardens the integration layer and transfers operating knowledge to the internal team.

The important distinction is that FDE is not conventional staff augmentation. It is also not advisory consulting that ends with a roadmap. FDE is outcome-oriented engineering in the field. The engineer is close enough to the customer environment to see real constraints, yet technical enough to change the system directly. In Agentic AI, that proximity matters because small details can decide whether a workflow is trusted: a missing approval step, an overly broad tool permission, an unlogged data access, a weak retry policy or an untested edge case can undermine the entire deployment. Forrester similarly positions agentic AI as a competitive frontier that requires leaders to redesign workflows, governance and engagement models rather than simply automate existing tasks.

Operationalizing multi-step agentic workflows

Operationalization begins by turning an agent idea into an explicit workflow. Instead of saying, “build an agent that handles vendor onboarding,” an FDE team defines the stages: collect supplier information, validate tax details, screen sanctions lists, check contract thresholds, request procurement approval, create a supplier record and notify stakeholders. Each stage is assigned to a deterministic function, an AI agent, a human approver or a hybrid step. This decomposition reduces ambiguity and makes it easier to govern the process.

In production, an FDE must design for state, retries, failures, idempotency and observability. Agentic workflows may run for minutes, hours or days. They may wait for an external API, pause for approval, recover from a system outage or resume after a user changes input. A robust implementation therefore needs checkpoints, durable state, structured event logs, trace IDs, policy-aware tool execution and dashboards that show where the workflow is stuck. Without these engineering controls, an agent may appear intelligent in a demo but become fragile in live operations. IDC’s perspective on agent adoption also highlights that the scale of enterprise agents will create major demands around orchestration, token efficiency, governance and cost containment.

Governing agentic AI through FDE

Governance in Agentic AI cannot be added as a final compliance checklist. It must be embedded into the workflow design. FDE teams help by translating policy into executable controls. For example, they can define which tools an agent may call, which data classes it can access, what confidence thresholds require escalation, which outputs need review and how exceptions are recorded. They also help establish evaluation datasets that reflect real operating scenarios rather than sanitized prompts.

A practical governance model usually contains five layers. The first is intent governance, which verifies that the agent is solving an approved business problem. The second is data governance, which controls source quality, access, retention and lineage. The third is tool governance, which restricts actions such as writing to systems, sending emails, executing code or changing financial records. The fourth is decision governance, which determines where humans must approve or override agent recommendations. The fifth is runtime governance, which monitors drift, failure patterns, cost, latency and policy violations. Gartner’s 2026 guidance on AI agent governance reinforces this need for differentiated controls, warning that uniform governance across all agents can create both over-restriction and under-restriction risks.

Securing agentic AI workflows

Security for Agentic AI is broader than prompt safety. Agents can act and every action surface must be secured. FDE teams typically implement least-privilege access, scoped credentials, tool allowlists, secrets isolation, input validation, output filtering, data loss prevention checks and protected execution environments. They also design approval gates for high-impact operations. A procurement agent may be allowed to draft a purchase order, but it should not submit the order above a threshold without explicit authorization.

Another important responsibility is defending against indirect prompt injection and tool misuse. If an agent reads an email, document, ticket or web page, that content may contain instructions that attempt to override the system policy. FDE engineers reduce this risk by separating instructions from data, sanitizing retrieved content, validating tool arguments, limiting write permissions and logging every external action. In regulated environments, they also design audit trails that show not only the final answer but the path the agent took to reach it. Forrester’s AEGIS framework similarly argues that agentic AI security must move beyond traditional infrastructure-centric controls toward intent-aware guardrails, observability, accountability and least-agency principles.

FDE and vibe coding: Relationship and tension

Vibe coding refers to a style of AI-assisted software development where a person expresses intent in natural language and an AI system generates much of the code. It can be extremely useful for prototyping, exploration, internal tools and rapid experimentation. In the context of FDE, vibe coding can accelerate the early build cycle because forward deployed engineers can quickly sketch integrations, generate boilerplate, create test harnesses and explore workflow alternatives with AI coding assistants.

However, FDE also provides the discipline that vibe coding alone lacks. An enterprise agent cannot rely on generated code that nobody has reviewed, tested or secured. The FDE approach turns intent-driven development into responsible engineering. The engineer may use AI to generate code, but then verifies it through code review, unit tests, integration tests, security checks, policy validation and operational monitoring. In short, vibe coding helps move faster; FDE ensures that speed does not come at the cost of reliability, maintainability or accountability. This aligns with Forrester’s caution that agentic systems can become harmful when they are misaligned, poorly governed or deployed without adequate experimentation and control.

Example: LangGraph with FDE orchestration

LangGraph is well suited for FDE-led Agentic AI implementations because it models workflows as graphs with state, nodes, edges, persistence and human-in-the-loop control. An FDE team can use it to build long-running, auditable workflows where every step is explicit. Consider a customer support escalation workflow. The graph may begin with ticket intake, move to classification, retrieve policy documents, ask a diagnostic agent to propose a resolution, route uncertain cases to a human reviewer and finally update the ticketing system.

In this model, the FDE defines the state schema, selects which nodes use LLM reasoning, separates deterministic validation from agentic reasoning and adds checkpoints so the workflow can resume after interruption. Human review is not an afterthought; it becomes a graph transition. If the confidence score is low or a policy exception appears, the workflow pauses for approval. This is an example of FDE orchestration: the framework supplies the runtime primitives, while the forward-deployed engineer shapes those primitives into a secure business process.

A simplified LangGraph-style pattern may include nodes such as intake_agent, retrieval_node, policy_checker, resolution_agent, human_approval and ticket_update. The FDE ensures that ticket_update can only run after validation and that sensitive customer data is masked before being sent to the model. The result is not merely an autonomous assistant; it is a controlled workflow that can be inspected, resumed, tested and improved.

Example: Microsoft AutoGen and Microsoft Agent Framework with FDE orchestration

Microsoft AutoGen popularized the idea of multi-agent conversations where agents with different roles collaborate to solve a task. In newer enterprise settings, Microsoft Agent Framework provides production-oriented patterns for agents and workflows, including sequential, concurrent, handoff, group chat and manager-led orchestration. An FDE can use these patterns to design a governed multi-agent system rather than a free-form conversation among bots.

For example, imagine an enterprise architecture review assistant. One agent reads the solution brief, another checks cloud security requirements, a third evaluates cost and FinOps implications and a fourth prepares a decision summary. A manager or orchestrator coordinates the agents, decides when to ask for missing information and routes the final recommendation to an architect for approval. The FDE defines agent roles, tool permissions, routing logic, approval-required actions and telemetry. If the security agent recommends a design exception, the workflow can pause until an authorized reviewer approves it.

In this case, FDE orchestration prevents the system from becoming an uncontrolled debate among agents. It introduces structure: which agent speaks when, which tools each agent may use, which outputs must be machine-readable and what evidence is required before a recommendation is accepted. This is especially important in Microsoft-centric enterprises where identity, audit, data boundaries and cloud governance must align with existing platforms.

Example: CrewAI with FDE orchestration

CrewAI is useful when the solution naturally maps to a team of role-based agents. It supports crews, tasks, processes, tools, memory and flows. An FDE team can use CrewAI to model collaborative work where specialized agents perform defined responsibilities. Consider a market intelligence workflow for a product team. A research agent gathers public signals, a competitor analyst compares positioning, a financial analyst estimates market impact and an editor agent prepares the final brief.

The FDE’s role is to make this collaboration production-ready. The engineer defines task boundaries, expected outputs, data sources, tool limits, escalation rules and quality checks. If the market intelligence brief is used for executive decision-making, the FDE may require citations, confidence notes, evidence tables and human approval before publication. CrewAI Flows can then be used to orchestrate event-driven execution, manage shared state and resume longer workflows where human feedback or external triggers are involved.

A practical CrewAI FDE pattern is to separate creative agent work from controlled workflow steps. Agents may draft, analyze and summarize, but deterministic validators check schema, sensitive content, data completeness and approval status. This hybrid design gives the enterprise the benefit of agent collaboration without surrendering control of the process.

Reference architecture for FDE-led agentic AI

A typical FDE-led Agentic AI architecture includes six layers. The experience layer contains chat, workflow, API or embedded user interfaces. The orchestration layer manages graphs, crews, workflows, handoffs, retries, checkpoints and human approvals. The agent layer contains specialized agents with defined roles, instructions, memory and tool access. The tool and integration layer connects to enterprise systems such as CRM, ERP, ticketing, document repositories, email, messaging, databases and APIs. The governance and security layer enforces identity, policy, secrets, monitoring, evaluation, logging and audit controls. The operations layer provides deployment automation, dashboards, incident handling, cost tracking and continuous improvement. Everest Group’s 2025 AI and Generative AI Services PEAK Matrix also notes that enterprises are moving beyond pilots toward production-grade AI initiatives, with emphasis on scalable architectures, responsible AI, security, compliance and outcome-based partnerships.

The FDE connects these layers into one operating system for AI adoption. The value is not only in the code. It is in the ability to make the code work inside the customer’s real environment, with the customer’s data, controls, users and accountability model.

Best practices for FDE in agentic AI programs

• Start with a business workflow, not with a model capability.
• Define measurable outcomes such as cycle time reduction, error reduction, risk reduction or user productivity improvement.
• Use explicit orchestration for multi-step processes rather than relying on open-ended agent behavior.
• Separate deterministic logic from probabilistic reasoning wherever possible.
• Apply least-privilege access to every agent, tool, connector and data source.
• Build human-in-the-loop controls for high-risk, low-confidence or irreversible actions.
• Create evaluation suites using real examples, edge cases, policy scenarios and adversarial prompts.
• Instrument every workflow with traces, logs, metrics, cost visibility and audit records.
• Use AI-assisted coding to accelerate delivery, but review, test and secure generated code before release.
• Design for transfer of ownership so the client team can operate and extend the system after deployment.

Conclusion

Forward-deployed engineering is becoming central to the Agentic AI era because it solves the problem that models alone cannot solve: making AI work safely, reliably and measurably inside real organizations. Agentic systems introduce autonomy, but autonomy without orchestration becomes risk. They introduce speed, but speed without governance becomes fragility. They introduce new coding possibilities, but AI-generated code without engineering ownership becomes technical debt.

FDE provides the missing bridge. It brings engineering to the field, policy into the runtime, security into the workflow and operational discipline into agent design. Whether the implementation uses LangGraph, Microsoft AutoGen, Microsoft Agent Framework, CrewAI or another orchestration stack, the core principle remains the same: enterprise Agentic AI must be co-designed with the business, governed by architecture, secured by default and operated as a living system. That is the practical promise of forward-deployed engineering. Everest Group’s Innovation Watch on Agentic AI Products further reinforces this direction by describing agentic AI as the next stage of automation, where autonomy, adaptability and decision-making are embedded into systems to improve efficiency and responsiveness.

This article was made possible by our partnership with the IASA Chief Architect Forum. The CAF’s purpose is to test, challenge and support the art and science of Business Technology Architecture and its evolution over time as well as grow the influence and leadership of chief architects both inside and outside the profession. The CAF is a leadership community of the IASA, the leading non-profit professional association for business technology architects.

This article is published as part of the Foundry Expert Contributor Network.
Want to join?