AI for Web and DXP Development Augmenting Rather Than Replacing

For many enterprise teams, AI represents a path to faster task execution, including software and DXP development. Work that typically takes weeks or months can be compressed into days.

However, companies that judge output only by speed often overlook that the same tools can slow teams down with added rework when they apply AI to the wrong tasks in the development process. Additionally, relying too much on AI can cause the development costs teams aimed to cut to skyrocket, as they're spent on tokens instead.

Enterprises thinking of using AI to completely replace the knowledge and expertise of software developers, particularly for tasks that require custom development and implementation, may be in for a rude awakening. In this article, we'll explain why and show how the right agentic approach can not only increase speed but also maximize ROI.

Key Takeaways

• AI compresses the coding phase of a DXP build but often extends the subsequent phases, since output that looks almost correct still needs senior review before it can ship.

• The returns are concentrated in contained work, such as content components, page assembly from an existing library, and test coverage. People still need to make custom business logic and architecture decisions before anything gets generated.

• Token costs increase if the work isn't specified correctly. Driving an interface with a model instead of calling an API, or iterating three times on a vague request, erases the savings enterprises were chasing.

• Oshyn runs agentic development inside the Wave Process, using proprietary MCP servers and client-specific skills so that generated code follows the conventions already in your DXP, with architecture and acceptance criteria defined up front and every line reviewed and scanned.

Why AI Alone Doesn't Shorten Enterprise DXP Timelines

When we began integrating AI into our workflows at Oshyn, we tested many available tools and plugins, including LLMs like Claude and ChatGPT, GitHub Copilot, Figma-to-code, and more.

While AI saved time on boilerplate and repetitive work, it fell apart once we applied it to broader systems. AI alone isn't sufficient for enterprise DXP development. Here are a few reasons why:

1. Code creation is only part of DXP implementation

The most critical aspects of DXP implementation can't just be handed over to artificial intelligence. While writing code is significantly reduced, other, more strategic content modeling, integration design, and content migration planning still require human input.

2. AI-generated code often leads to rework

Speed in the coding phase can inadvertently lengthen the subsequent phases. Stack Overflow's 2025 developer survey found that 66% of developers reported that AI output tends to be almost right without being right, meaning senior developers spend more time reviewing code for accuracy than they would like. In fact, 45% of developers believe that debugging AI code is more time-consuming.

AI-generated code only works well if it never needs to be readable by a human and can exist in a black box. However, for a live production system like an enterprise DXP, where senior developers need to review and edit code, it isn't sufficient.

3. AI is often applied to the wrong part of the process

Compressing DXP implementation timelines comes from deciding on architecture and acceptance criteria before anything gets built, moving advanced features out of a phase that has historically absorbed months, and putting rigorous QA into the build rather than after it. While AI can support parts of this process and work well once this initial structure and process are in place, it can't create the structure itself.

Where Agentic Development Fits in a DXP Build

Enterprises weighing AI for a DXP implementation get consistent returns in a specific set of places:

• Content components: Card carousels, body text blocks, image-text modules, and other low- to medium complexity components where the behavior is contained. In this category, Oshyn has seen development effort drop by approximately 70 percent, turning content-managed websites that previously took weeks to build into ones that take days.

• Content-only page builds: Assembling pages from an established component library, where AI applies existing patterns rather than inventing them.

• Content modeling: Extending an existing model with new fields and blocks, as both builds below demonstrate, provided a person owns the schema decisions that downstream templates depend on.

• Test coverage: Writing and maintaining the rigorous testing cycles that routinely inflate implementation timelines. Both unit tests at the code level and UI tests can be created faster than a developer can do by hand.

• Migration verification: During a migration, AI can confirm whether content from an old page has been migrated to a new page. Previously, this meant matching HTML characters one by one, so the two pages had to be nearly identical for the check to pass. A model can do a fuzzy match instead and return a confidence percentage on whether everything is present.

Where It Doesn't

However, the same tooling produces rework, or worse, when it is pointed at the wrong parts of an implementation, including:

• Custom business logic: Rules specific to your organization that exist in no training data and cannot be inferred from the codebase.

• Architecture and integration design: AI performs well within a defined structure, but is unreliable at providing one. These decisions must come first and depend not only on the choice of DXP but also on each organization's unique characteristics, including team makeup, the number of digital properties, and integrations.

• Unreviewed output at volume: AI optimizes for plausibility, so AI-generated code can look correct and behave correctly in simple scenarios, while something underneath is wrong. Hence, production systems require a developer to review code before it ships to avoid issues.

The Cost of Agentic DXP Development

Another factor to consider, particularly when leveraging various LLM and coding tools, is the costs associated with them. While some enterprises cite cost savings as the reason for using AI instead of agencies and developers, they still need to manage costs.

The appeal of agentic tooling is that anyone can describe what they want in plain language and watch something get built. However, asking a model to drive a browser, log in to a screen, or operate a desktop requires an enormous number of tokens to accomplish something that an API call handles for a fraction of the cost.

The same applies to iteration: a request that takes three attempts costs three times as much as a single well-specified request. Consequently, the people best positioned to extract the most value per token are the ones who already know how to structure the work.

Using AI Tokens Efficiently

Efficiency comes from building technology workflows connected to APIs rather than pointing a model at an interface and letting it improvise. It comes from specifying the work before the build starts, so AI is not exploring the problem at your expense, and from knowing which parts of a build justify inference cost at all.

This is where Oshyn's efficient use of tokens is best demonstrated: we build API-connected workflows rather than having models operate interfaces, and we scope AI work to the component categories where the economics are proven.

How Oshyn Approaches Agentic DXP Development

Oshyn's agentic development practice runs inside the Wave Process we have used on enterprise DXP implementations for two decades. AI takes on the foundational architectural work and rigorous testing cycles that historically filled the middle of a project, freeing senior developers to focus on strategy and custom business logic.

Our proprietary MCP servers are built for the platforms we implement, and custom skills developed per client mean generated code follows the existing patterns and conventions in that organization's DXP rather than generic defaults.

Additionally, we define the architecture, integration strategy, and acceptance criteria before generating any code, and every line of generated code goes through review, automated vulnerability scanning, and validation, just as it would with a team of human developers.

What Agentic Web Development Looks Like on an Enterprise DXP

Starting from a Figma design, Oshyn developers can build an image-text component by prompting an agent and describing what to build.

From there, in just a few minutes, it retrieves the design context, creates the module and its fields, generates the React component and stylesheet, registers the component, and runs a successful build. The verification pass shows the expected file structure in VS Code and the new rendering and templates in the DXP. The component then goes onto the homepage and the about page, matching the original design.

The Oshyn MCP server makes this possible by allowing an AI assistant to call live tools and access real data mid-conversation, rather than relying on guesswork.

Getting More Out of AI Web Development With Oshyn

With agentic DXP development, advanced marketing features, personalization, and automated testing can be part of the initial build instead of phase two, and marketing teams can start creating content and running campaigns months earlier than a traditional implementation would allow.

Additionally, if you want access to Oshyn's expertise while you decide on your next DXP project, connecting your AI assistant to the MCP server lets you ask questions in plain language and have your assistant call the right Oshyn tool in the background. It can help identify gaps in how AI sees your brand, evaluate site reliability, explore DXP options, estimate project budgets, get Oshyn insights, and guide planning conversations without leaving your chat.

If you are planning a redesign, replatform, or migration and want to know how agentic delivery would change your timeline and budget, contact us.