WaveMaker’s Agentic App Generation System: Interview With Head Of Product Experience Vikram Srivats

WaveMaker is an architecture-first, agentic AI-based web and mobile application generation system for early developer teams in enterprises and midmarket businesses. As Head of Product Experience, Vikram Srivats is responsible for all aspects of product-market fit, including driving go-to-market (GTM) strategy. Pulse 2.0 interviewed Vikram Srivats for this article.

Vikram Srivats’ Background

Could you tell me more about your background? Srivats said:

“I’m a Mechanical engineer by training with a graduate degree from India’s top science university, the Indian Institute of Science, who somehow ended up in the fascinating intersection of hi-tech and software products with enterprise customers since I started over 20 years ago.”

“My career has followed a pattern: I keep finding myself at the early stage of hard technology problems where the product-market fit isn’t obvious yet, and the job is to figure out what matters to customers, build the narrative, and scale it. At Mindtree, a $3 billion revenue company today, I was the founding general manager of an Internet of Things business that I incubated from scratch. Before that, I took over a brilliant team and an R&D lab and helped establish it as the number-one independent licensor of Bluetooth Smart silicon and software IP globally. Earlier in my career, I shaped the enterprise go-to-market for what was arguably India’s first indigenous handheld computer, a product built to address the digital divide.”

“I’m genuinely moved by making possibilities real and have always been drawn to the moment when a product or technology goes from being technically impressive to being genuinely useful to a business. That’s what drew me to WaveMaker. When I joined, the company had a deeply sound technical foundation, a decade of deterministic code generation, enterprise-grade architecture, and zero lock-in, but the world didn’t yet fully appreciate why that mattered. Then AI changed everything, and suddenly, the case for determinism became the most important conversation in enterprise software. I’ve held several roles at WaveMaker, including VP of Strategic Markets, making deep inroads in the world of financial services and software. Today, as Head of Agentic Product Experience, I’m responsible for the end-to-end product experience of our agentic application generation platform from how customers first encounter WaveMaker to how their development teams use it daily to ship production software.”

“I also write regularly on Substack about the themes I care about: why deterministic software engineering is making a comeback, why design quality matters more (not less) in the AI era, and how enterprise development teams can navigate the hype cycle without losing their footing.”

 

Formation Of The Company

How did the idea for the company come together? Srivats shared:

“WaveMaker’s story starts with Pramati (meaning ‘exceptional minds’), our parent company, which was founded in 1998 by Jay and Vijay Pullur in Hyderabad. Pramati built the world’s first J2EE-certified application server, competing directly against Oracle, BEA, and IBM, and winning. By 2001, every one of India’s top ten banks ran on Pramati infrastructure. That’s the DNA: enterprise-grade platform technology built under intense competitive pressure.”

“In 2013, Pramati acquired the WaveMaker product from VMware and set out to solve a problem the team had experienced firsthand: enterprise application development was too slow, too expensive, and too dependent on scarce full-stack talent. But every platform that promised acceleration imposed proprietary lock-in that professional developers couldn’t accept.”

“The founding bet was radical for the low-code market at the time: generate standard open-source framework code, Java, Angular, Spring, with absolutely zero proprietary runtime. Customers would own their code completely and could walk away at any time. That decision meant WaveMaker couldn’t compete on the same “magic” promises as platforms that locked customers in. It was the harder path. But it built something more durable: trust from enterprise engineering teams who had been burned by vendor lock-in before.”

 

Favorite Memory

What has been your favorite memory working for the company so far? Srivats reflected:

“There’s a moment I keep coming back to. It was during a proof-of-concept with a large financial services company who had evaluated 17 different platforms across 30 criteria before even talking to us seriously. They were rigorous, skeptical, and had very specific requirements: on-premise deployment, Sybase database connectivity, AG-Grid and Highcharts integration, role-based access control. The kind of list that most demo-friendly platforms quietly fail on.”
“Our team ran a multi-phase evaluation with their engineers. At the end, their MD did the math: 4x FTE leverage during the PoC. But what stuck with me wasn’t the number. It was something one of their engineers said after the evaluation: ‘WaveMaker checked most of the boxes, and we actually trust the code it produces.’ That word “trust” from a professional developer evaluating the output of a platform, is the highest compliment this kind of product can receive. It validated everything we’d built.”

What are the company’s core products and features? Srivats explained:

“WaveMaker’s Agentic Application Generation Platform is built for enterprise developer teams shipping production-grade web and native mobile applications. The core innovation is a two-pass architecture that separates what AI is great at from what AI is terrible at.”

“In the first pass, AI agents, constrained by a Model Context Protocol trained on a decade of production application patterns, convert design intent into WaveMaker Markup Language, or WML. This is a compact, structured, language-agnostic intermediate representation. In the second pass, a proven template-based code generator converts WML into production-ready code: Angular, React, or React Native on the frontend, Spring and Hibernate on the backend. Same input, same output, every time. No hallucinations, no phantom dependencies.”

“Around that core architecture, we deliver: Design-to-Code agent, a Figma plugin for design-to-code conversion with full design token propagation; a rich enterprise UI component library built on Material 3; a visual WYSIWYG Studio where developers can toggle between agent mode, visual mode, and code editor mode; built-in security configuration covering RBAC, SSO, OAuth, and MFA; API integration via Open API and Swagger; and native Git and CI/CD pipeline support. The generated code is standard open-source frameworks that are downloadable, deployable anywhere, with zero runtime lock-in.”

 

Challenges Faced

Have you faced any challenges in your sector recently? Srivats acknowledged:

“The biggest challenge has been navigating the gap between AI coding hype and enterprise reality. The market narrative in 2024-25 was intoxicating: AI will write all the software, everyone becomes a programmer, development costs drop to near zero. That narrative attracted enormous venture funding and media attention to tools like Cursor, Copilot, Replit, and v0.”
“But enterprise teams who adopted these tools encountered a set of problems the hype cycle glossed over. AI-generated code introduces 1.7 times more issues than human-written code. Security flaws appear in 45% of AI output. 67% of developers report spending more time debugging AI-generated code than writing it themselves. Google’s own DORA report showed a 7.2% drop in delivery stability among teams using AI tools.”

“For WaveMaker, the challenge was positioning ourselves in a market where “AI coding” had become synonymous with raw, non-deterministic code generation when our approach was architecturally different. We had to educate the market that speed without reliability isn’t acceleration, it’s chaos with better marketing. The two-pass architecture, the constrained markup layer, the deterministic second pass, these are the concepts that required explanation in a world conditioned to judge AI tools by how fast they produced code. We overcame it by leaning into thought leadership, publishing research, and letting architecture speak for itself in customer evaluations.”

 

Evolution Of The Company’s Technology

How has the company’s technology evolved since launching? Srivats noted:

“WaveMaker started as a WYSIWYG, open-standards development studio, which is essentially a visual IDE that generated real Java and Angular code instead of proprietary artifacts. That was already differentiated in the low-code market, but it was fundamentally a visual development tool.”

“The first major evolution was adding a native mobile application studio. We delivered a React Native code generation engine for our enterprise customers and software companies who wanted to deliver a cross-platform companion or deskless high-fidelity application to their users or customers. The second was the composable architecture, enabling teams to build reusable components and assemble enterprise applications from modular building blocks, including supporting micro-frontend patterns.”

“The most consequential evolution came in 2025-26 with the introduction of AI agents and the two-pass architecture. Rather than adding AI as a chatbot sidebar, which is what most platforms did, we rearchitected the generation pipeline. We leaned in on our WaveMaker Markup Language (WML) as an intermediate representation, constrained AI through MCP, and kept the deterministic code generator as the final pass. This wasn’t an incremental feature; it was a fundamental architectural decision that redefined what the platform is: from a visual development studio to an agentic application generation platform. The Figma-to-app pipeline, the agent framework for custom domain-specific agents, and the style workspace for design system management were all built on top of this new architecture.”

 

Significant Milestones

What have been some of the company’s most significant milestones? Srivats cited:

“Several milestones stand out across our history. In 2014, we launched WaveMaker Online as one of the first cloud-based developer studios using Docker container orchestration provisioning developer workspaces in seconds, which was pioneering at the time. Building a customer base across 17 countries with enterprise clients like FICO, FIS, and AT&T validated that professional developers would adopt a platform that respected their code ownership. In 2023, WaveMaker was recognized by five industry analysts in a single year, including a position in the Omdia Universe for No Code/Low Code Solutions. In February 2025, we launched our AI-powered Figma-to-code plugin. In February 2026, we officially entered the agentic era with the launch of the two-pass architecture and the full agentic platform. That same month, our WaveXD 5G-integrated application marketplace won the Juniper Research Future Digital Award for Telco Innovation. And our collaboration with AT&T on mobile application experiences for influencer MVNOs opened an entirely new market vertical. Today, applications built using WaveMaker’s platform are shipping to millions of end users and consumers in the U.S. and globally.”

 

Customer Success Stories

Can you share any specific customer success stories? Srivats highlighted:

“For some of our customers who are large US public corporations in financial services and telecommunications, delivering to their exacting requirements around integration, UX, performance, security, and architectural governance in themselves has been a tremendous success. In a particular case, WaveMaker’s powered a mobile-first digital banking platform that is being used by millions of consumers with very high app store ratings. That is what we mean by enterprise-grade and consumer-scale, especially in these regulated industries where the code quality, security posture, and architectural consistency of generated applications isn’t optional, it’s audited.”

“We have helped Indonesia’s state owned petrochemical company completely rearchitect and migrate from over a 100 legacy Lotus Notes applications to a modern, rationalized Java/Angular based application stack within months. Belgium’s largest supermarket retailer, Colruyt Group, uses WaveMaker as a standardized accelerator for early developer teams, delivering architecture and guardrails out of the box. Blue Yonder, a global supply chain software leader, uses WaveMaker to support extensibility in areas of their supply chain solutions. These relationships span years, not quarters, which is the real test of an enterprise platform. Our enterprise customer base has experienced minimal churn which tells you more about product-market fit than any marketing metric.”

 

Funding/Revenue

Are you able to discuss funding and/or revenue metrics? Srivats said:

“WaveMaker is a Pramati group company, and Pramati has been self-funded for over two decades with group company revenues and proceeds from M&A. It gives us the freedom to make product decisions based on what’s right for customers on a multi-year horizon.”

“Pramati’s track record includes building and exiting multiple portfolio companies: Qontext (social platform for enterprise collaboration) was acquired by Autodesk, Imaginea (Cloud services) was acquired by Accenture, and SpotCues (deskless worker platform) was acquired by UKG in 2022. These exits demonstrate the ability to build durable products that attract acquirers, while the parent company maintains independence and continues investing in new ventures.”

“WaveMaker has grown net subscriptions every year since 2016. Our licensing model is annual subscriptions based on developer seats, with zero runtime fees which means our revenue scales with customer adoption, not with production usage metering. We currently serve customers across 17 countries.”

 

Total Addressable Market (TAM)

What total addressable market (TAM) size is the company pursuing? Srivats assessed:

“The global enterprise application market is projected to grow from $320 billion to $626 billion by 2030, according to some estimates. Within that, the AI code generation market is expected to reach approximately $25 billion by 2030. WaveMaker sits at the intersection of both: enterprise application development accelerated by AI.”

“Our specific addressable market is in midmarket with early developer teams building custom, UI-heavy, multi-platform web and mobile applications, particularly in financial services, insurance, telecommunications, supply chain, and enterprise software. These are organizations with 5 to 500 developers who need production-grade output, architectural governance, and predictable costs not weekend prototyping tools or individual coding accelerators.”

 

Differentiation From The Competition

What differentiates the company from its competition? Srivats affirmed:

“The competitive landscape segments into four categories, and WaveMaker occupies a distinct position in each comparison.”

“Against coding accelerators like Cursor and Claude Code: they make individual senior developers faster; WaveMaker normalizes output quality across entire teams through constrained markup generation and deterministic code output. They have no design system awareness; we treat design systems as first-class architectural artifacts.”

“Against vibe coding platforms like v0 and Lovable: they excel at beautiful prototypes; WaveMaker is built for production. They’re locked to specific ecosystems (v0 to Vercel/Next.js); we generate standard code deployable anywhere.”

“Against design-to-code tools like Locofy: they convert Figma to frontend code; WaveMaker goes full-stack, frontend, backend, API integration, security, deployment, all from a single specification.”

“Against enterprise low-code platforms like OutSystems: they require proprietary runtimes and certified developers; WaveMaker generates standard Angular, React, React Native, and Spring Boot with zero lock-in. Any Java/JavaScript developer can work with our output.”

“The unique combination of deterministic output, design system governance, full-stack generation, multi-platform targeting, and zero runtime lock-in exists nowhere else in this landscape simultaneously.”

 

Future Company Goals

What are some of the company’s future goals? Srivats emphasized:

“Near-term, we’re focused on expanding early access adoption for the agentic platform and demonstrating the two-pass architecture in production customer environments. We want enterprise teams to experience firsthand what it means to go from Figma design to deployed multi-platform application with deterministic, auditable code.”

“We’re deepening our agent framework so organizations can build custom domain-specific agents that inherit the same reliability guarantees — imagine a financial compliance agent or a supply chain integration agent that produces governed, deterministic output for highly specialized workflows.”

“On the market side, we’re expanding our system integrator partner ecosystem and strengthening our presence in financial services, insurance, telecommunications, and supply chain.”

“Longer-term, we believe the enterprise application development market is heading towards an agent-driven generation model with guardrails and architecture built-in — where AI composes interfaces dynamically from governed component libraries, adapting to each user’s context and role. WaveMaker’s design system infrastructure and WML architecture are the foundation for that future. We’re building toward it deliberately.”

 

Additional Thoughts

Any other topics you would like to discuss? Srivats concluded:

“One thing I think about a lot, borrowing from a recent article authored by my colleague and CTO, Deepak Anupalli, is the paradox of UX in the AI era. There’s a widespread assumption that AI will simplify interfaces to the point where design doesn’t matter. The reality is the opposite.”

“As AI automates away the easy, repetitive interactions such routine data entry, and simple form filling and what remains are the high-stakes decisions: a wealth advisor approving a million-dollar portfolio rebalancing, a supply chain manager responding to a stockout alert, a compliance officer reviewing an AI-generated audit narrative. These interactions don’t need less design; they need profoundly better design. The UX becomes the trust surface.”

“Enterprise applications typically blend five distinct interaction types — transactional, exploratory, data entry, analytical, and adaptive agentic — each with different trust requirements. A single generic AI-generated UI cannot serve them all. That’s why WaveMaker’s design-governed approach matters: we ensure that each interaction type gets the trust-appropriate UX treatment it requires, enforced through the generation pipeline rather than hoped for through documentation.”

“I believe the companies that understand this – that design is the guardrail AI needs, not decoration AI replaces — are the ones that will build lasting enterprise software in this era. That’s the thesis WaveMaker is built on, and it’s what drives me each day.”

This interview is originally published on Pulse 2.0.

Horses and Tigers Are Different : Why AI Is Unlike Every Technology Platform Shift Before It

AI differs from previous technology waves because it increasingly performs the implementation work that historically created demand for IT services. Drawing on 35 years of experience across ERP, SaaS, cloud, and AI, Vijay Pullur argues that the future belongs to organizations that transform domain expertise into proprietary software products rather than relying solely on labor-based services.

The rapid rise of large language model platforms – Anthropic, OpenAI, Google Gemini – has put the global IT services model in serious jeopardy of becoming obsolete. Dramatic as that sounds, I believe it is precisely the right framing.

Since January 20th, shares of virtually every major global IT services company have dropped between 20 and 30 percent. Accenture is down roughly 30 percent. IBM is down 24% with a single-day 13% decline around February 23rd-24th. Wipro and Coforge have shed nearly 25 percent. TCS, Infosys and HCL Tech are all trading at multi-year Lows.

The only comparable sector decline in such a compressed window was COVID-era 2020 – except that time, the Dow Jones fell 39 percent alongside them. This time, the Dow is essentially flat.

The broader economy is not in crisis. It’s the IT services business model that the market is repricing – and it is signaling a seismic shift.

Previous Platform Shifts AI
Needed implementation partners Performs implementation
Expanded services demand Compresses some services demand
Separate product and service Increasingly combines them
More consultants required More automation possible

 

Mounting the Horse: A 35-Year Playbook

AI impacting traditional revenue models built around human capital seems to be the central story for this collapse. However, nearly every major IT services firm has announced an AI partnership. Accenture joined OpenAI’s Frontier Alliance alongside McKinsey, BCG, and Capgemini. TCS, Infosys, and Wipro all have deals with Anthropic, OpenAI, or Google.

In previous cycles, announcements like these would lift a company’s stock for weeks. This time, Accenture’s shares fell 6.6 percent on the very day it announced its OpenAI partnership. The market is not buying the story.

The 35-year IT services playbook used to be: announce a partnership with the rising platform, stand up a competency center, train people, and use the partner’s brand to win enterprise contracts. SAP and Oracle in the ’90s for ERP implementation. Salesforce in the 2000s for SaaS-led services. AWS, Azure, and Google Cloud in the 2010s for Cloud migration. Each time, the software platforms made clear that services were not their business. They left the gap open. Services firms filled it and built empires. I call this “mount the horse and ride.” We did exactly this at Imaginea – the technology services company I co-founded under Pramati, later acquired by Accenture. Pick the fastest horse early enough, and you win.

Not anymore.

 

AI Is Different. You’re Riding a Tiger.

What is an AI platform shift?

Unlike cloud computing or SaaS, AI platforms increasingly automate portions of the software development and implementation process itself, changing the economics of IT services rather than simply introducing another technology stack.

In every previous cycle, technology vendors needed IT services companies. But AI does not need implementers in the same way – it is the product and service – rolled into one. When Claude Code can automate COBOL modernization, and when the CEOs of Anthropic and OpenAI publicly state that software engineering roles will largely disappear within three years, they are not describing disruption. They are describing replacement. On a horse, you are in control. The tiger turns on you eventually.

Jefferies just downgraded TCS, Infosys, HCL Technologies, and three other major IT firms, explicitly citing AI as a structural threat to the business mix. JP Morgan warned that clients will reallocate spending as AI-led efficiencies shrink demand for managed services. This is now the mainstream analytical consensus – not a fringe view.

 

Build the Moat or Become Irrelevant

The answer is not another partnership announcement. The era of scaling revenue by scaling headcount is over. The firms that survive will use their deep domain expertise— the genuine understanding of how enterprises actually work—to build proprietary software assets. Proprietary software assets are reusable software products, platforms, frameworks, or intellectual property that generate value independently of billable engineering hours. Products that clients cannot simply replace with a prompt. Use AI to build at extraordinary velocity but build something that is yours. The most pragmatic path may be acquisition: seed a product culture with companies that already have it and play the game with your software; not just your services.

This blog is originally published on Business Today.

 

FAQs

Q1. What does "mount the horse" mean in tech services history?

"Mount the horse" describes the strategy that helped IT services companies grow through previous technology waves. When platforms such as SAP, Oracle, Salesforce, AWS, Azure, or Google Cloud emerged, services firms built expertise around them, trained engineers, became implementation partners, and helped enterprises adopt those technologies. This approach proved highly successful for decades because platform vendors relied on services firms to drive adoption.

Q2. What is the "riding a tiger" analogy for AI in business?

The "riding a tiger" analogy illustrates why AI differs from previous technology platforms. Earlier platforms depended on IT services companies for implementation, allowing both platform vendors and services firms to grow together. AI, however, increasingly performs some of the implementation work itself. In that sense, AI is not simply another platform to ride - it is a force that can fundamentally reshape or even replace parts of the traditional services business model, requiring companies to rethink how they create long-term value.

Q3. How is generative AI replacing traditional IT implementers?

Generative AI is automating many software development tasks that previously required large implementation teams, including code generation, application modernization, documentation, and testing. While human expertise remains essential for enterprise architecture, governance, and business strategy, AI is reducing the amount of manual implementation work that has historically driven revenue for IT services firms.

Reimagining AI-Assisted Coding for Team Scale in Enterprises

AI coding tools have advanced rapidly, but most AI-assisted coding tools are still designed around the individual developer. Whether you're using an AI coding assistant inside an IDE or evaluating modern AI code generation tools, their effectiveness depends heavily on a user’s ability to write understandable prompts, preserve architectural coherence across sessions, and identify areas that require additional work. This model works for some engineers, but it is far less dependable for a large organization’s development team, where enterprise software must align with defined standards, delivery processes and governance requirements.

Today, AI development systems that reduce reliance on individual judgment are coming to market. Rather than functioning as standalone AI coding tools, they bring embedded structure, constraints, and verification directly into the platform. For organizations, customer-facing products and portals, building custom, design-led, mission-critical applications, the question is no longer whether AI can generate code. The real question is what an AI coding platform must look like to enable repeatable, reliable delivery at AI speed.

The Limits Of Prompt-Based Development In Enterprise Software Delivery

Software delivery follows established patterns in most mature organizations. Teams work within approved technology stacks, design systems, security policies, and clear expectations around testing and release quality. General-purpose coding agents, however, typically require these constraints to be recreated through prompts. Developers end up pasting in long instructions and specifications, repeatedly re-establishing project context, reminding the model of standards, and defining what “done” looks like despite limited context windows that can drift as the codebase grows in size, scope, and complexity.

This model carries a hidden cost. Teams spend valuable time following and keeping track of instructions instead of building features, and results vary widely depending on who is using the tool. In environments with multi-disciplinary, cross-functional teams, that variability becomes a real risk. It can degrade user experience, undermine architectural integrity and increase review cycles and remediation efforts downstream.
AI coding products built for teams should treat specs, application architecture, context, and guardrails as historical context and information, embedded in the system, rather than as prompts.

Rules Before Creativity For High-Functioning Architecture

Historically, clean architecture was rarely the primary challenge in mature enterprise software environments. The real priorities were, and remain, user experience, consistency, long-term maintainability, and adherence to established standards. An AI development platform built for teams should reflect that reality by providing a controlled range of acceptable outputs so generated code always aligns with organizational patterns.

For this to become reality, AI-powered coding tools must come with realistic, modern defaults and enforceable policies. This includes how components are prioritized, how data is accessed, which security checks are required, how errors are remediated, and which dependencies receive approval.

Embedding these standards also strengthens AI-assisted secure coding, reducing the chances that generated applications introduce security or compliance issues while allowing developers to focus on delivering business functionality.

Specifications Should Be Structured, Modular And Enforceable

Specifications used in AI-assisted development are more effective when they are not treated as a single document. A spec should be structured in a way that aligns with how agent-based systems operate and modular enough for teams to apply only the relevant portions to a given feature without reintroducing full project context each time.
In practice, a specification model requires clearly defined sections for scope, constraints, project structure, conventions, and boundaries. Versioning enables changes to be tracked over time, while enforceability allows the system to detect deviations or violations rather than relying solely on text generation that appears compliant. This approach can function as a shared operating model for a team rather than a collection of individual prompts.

Structured Intermediate Models Help Preserve The Design

A key design consideration for modern AI code generation tools is whether code is generated directly from natural language or produced from an intermediate representation that captures intent before code generation begins.

For team-based enterprise web application development, a multi-stage approach is often the most effective. Requirements and design inputs are first translated into a structured representation of the application—including screen composition, component mapping, bindings, and constraints—before framework-specific code is produced.

This significantly reduces regeneration of large sections of code, minimizes architectural drift, and creates a stable reference point that can be reviewed and validated.

For organizations building modern enterprise business applications, an intermediate representation also improves collaboration by allowing designers and product stakeholders to review application intent while engineers retain responsibility for implementation.

Policies Should Be Built-In And Consistently Applied

Organizations rely on policies or safeguards to manage risk and reduce variability across teams. When AI coding systems require individual users to define these policies in their prompts, the outcomes can vary significantly between developers and teams. Platforms intended for organizational use typically need to apply guardrails at the system level so they are shared and consistently enforced.

These policies should be in place at all levels. Some may take the form of hard constraints that prevent undesirable patterns and others may function as policy checks confirming architectural rules, security requirements and coding conventions. Workflow-related controls, such as review and approval steps, are also relevant. In design-led applications, user interface rules surrounding components, design tokens, and accessibility baselines play a similar role.

The purpose of these policies is not to limit the work being completed, but to ensure that increased development speed does not introduce additional operational risk or quality degradation.

Completion Criteria Should Be Provable And Clear

One recurring challenge in AI-assisted development is determining when work is complete. While code generation can be rapidly created, teams still need the confidence to determine when outputs meet acceptance criteria, pass required tests, integrate correctly, and comply with relevant policies. AI coding systems designed for team environments benefit from providing a clear, machine-verifiable definition of completion.
In practice, this involves associating requirements with acceptance criteria, expecting appropriate test coverage, executing checks automatically, and identifying gaps between the specification and the current implementation. Systems that can iterate in a controlled manner, proposing corrections and stopping when criteria are met, reduce the need for repeated reviews and increase confidence in the output.

Collaboration And Governance Must Be Supported By The Product

For AI coding systems to be effective in team environments, collaboration and governance capabilities need to be integrated into the product itself. Shared standards, templates, and design systems are necessary to ensure consistency. Role-based permissions help distinguish between who can modify standards and who can generate or modify features. Auditability is also important, enabling teams to understand which specification version informed an output and how changes were introduced.
Integration with existing delivery infrastructure, such as source control, CI/CD pipelines, and issue tracking systems, further supports adoption in established environments. Without these capabilities, AI coding tools are more likely to function as individual productivity aids rather than systems that support organizational delivery processes.

Distinguishing Between Tools And Delivery Systems

One way to evaluate the maturity of an AI development platform is to measure how much it depends on the user's expertise.
When consistent results require exceptional prompting skills, architectural knowledge, or manual review, adoption rarely scales across an organization.

The next generation of AI coding tools will increasingly resemble complete enterprise application platforms rather than standalone assistants. They preserve design intent, enforce application architecture, embed governance, and define completion through measurable outcomes instead of subjective judgment.

For organizations building customer-facing enterprise applications, the conversation is shifting beyond faster code generation. Success increasingly depends on delivering maintainable, governed, and architecturally consistent software at scale.

 

FAQs

  1. What are the top features of an enterprise application development platform?
    An enterprise application development platform should provide far more than AI code generation. Key capabilities include support for enterprise application architecture, reusable design systems, policy-based governance, role-based access control, versioned specifications, automated testing, secure coding practices, CI/CD integration, and interoperability with existing enterprise software ecosystems. AI-powered development platforms that combine these capabilities with deterministic application generation help organizations accelerate delivery while maintaining consistency, compliance, and long-term maintainability.
  2. How can I get started with AI-assisted coding?
    Getting started with AI-assisted coding begins by identifying repetitive development tasks where AI can improve productivity, such as generating boilerplate code, building user interfaces, or implementing business logic. For enterprise teams, the next step is choosing an AI coding platform that supports existing application architecture, security policies, development frameworks, and team collaboration. Rather than relying entirely on prompt-based coding, organizations benefit from platforms that provide reusable specifications, shared guardrails, and governance capabilities that enable consistent enterprise application delivery across teams.
  3. What are the best AI-assisted coding tools available?
    The best AI-assisted coding tools do more than autocomplete code or generate snippets. Enterprise development teams should evaluate platforms based on how well they preserve application architecture, enforce organizational standards, support secure coding, and integrate with existing development workflows. Features such as shared specifications, policy enforcement, design-to-code capabilities, structured intermediate representations, and CI/CD integration become increasingly important when building enterprise applications at scale. Platforms that combine AI with governance and deterministic application generation are typically better suited for enterprise software delivery than tools designed solely for individual productivity.

 

This blog is originally published on DevOps.com

AI Meets Determinism: A Hybrid Two-Pass Architecture for Controlling Variability in AI

For years, until recently, software did exactly what it was told. Developers meticulously coded precise step-by-step instructions for various processes. When executed, it did exactly that and nothing else. No matter how many times the code ran, the outcome was identical. It was totally deterministic.

AI, however, introduced the idea that software could “think” — assess a situation, evaluate various options, plot the best path forward, and in some situations, execute those steps. Run code multiple times and you may get structurally different code — different variable names, different logic paths, different dependencies.

This variability has been anathema to the need for reliability and consistency that users trusted in software for years — and that the industry has spent half a century trying to eliminate.

Although AI opens up an array of exciting new possibilities, left on its own, AI has demonstrated that it can go wildly off the rails.

Still, the solution isn’t necessarily to try to make AI deterministic, but to architecturally bake guardrails into the system itself to keep variability within acceptable limits.

When AI Goes Rogue

The inherent dangers of just throwing AI at a problem have been well publicized. It can hallucinate. It can spill secrets. Even with the right permissions and policies in place, it can do massive damage, not only internally, but also to a company’s reputation.

In one instance involving Cursor, a Claude-based IDE, and Supabase’s Model Context Protocol (MCP), an agent with broad database privileges was tricked into exfiltrating secrets using a user’s support ticket text.

The large language model (LLM) agent did so without violating any database permissions.

In another example, a Replit agent, in the midst of building an application, ignored explicit instructions to freeze changes and instead deleted an entire production database —months of real user data just gone. Leading up to this, despite being repeatedly instructed not to create synthetic data, it had made up thousands of fake database records. Afterward, it created its own human-like apology. Woops, sorry indeed.

The risks — hallucinated dependencies, security vulnerabilities that look correct on the surface, logic errors that only surface in production, and code that no two runs produce identically — are among the reasons Gartner recently predicted that over 40% of agentic AI projects will be canceled by 2027. 

Those risks have leaders uneasy. Eighty-three percent of AI leaders now report major or extreme concern about generative AI, an eight-fold increase since 2023, according to a Lucidworks study.

Yet only 1 in 5 (21%) companies in the Deloitte survey report having a mature model for governance of autonomous agents.
Deloitte also found that 10.69% of respondents admit to using AI coding assistants without official permission, in an unverified or unmonitored way, which no doubt has their bosses pulling their hair out.

A Hybrid Two-Pass Architecture

So, the question around AI isn’t so much about whether to use it all, but how to limit the damage it can do while still taking advantage of its “thinking” capability — and possibly ability to act as well.

One approach might be a two-pass hybrid model to architecturally put guardrails into the system itself. It might look like this:

Pass One: An LLM, trained on and constrained by a Model Context Protocol (MCP) derived from a deterministic, model-driven code generator, converts natural language intent into a lightweight language-agnostic intermediate markup expressed in a vocabulary the AI has been trained to produce reliably. Because the MCP defines strict boundaries — valid components, allowed patterns, supported data structures — it prevents hallucination.

Pass Two: A proven, model-driven code generator takes that markup and converts it into production code, whether that be JavaScript, Python or React, or even multiple languages. It produces the same reliable output every time and eliminates stylistic differences among different developers. It provides the consistency, compliance, testability, and maintainability that organizations have long relied on.

This hybrid model addresses barriers leaders most often cite — integration with legacy systems, security risks, lack of technical expertise — because each pass enables each of the different technologies to do what it does best. Generative intelligence is focused on understanding intent, interpreting natural language and reasoning about application behavior, and it delegates what it does worst (producing identical, production-grade code across runs) to a system purpose-built for that job.

AI converts natural language to specification. The code generator handles the engineering leap from specification to code.
It gives every developer — regardless of experience, language proficiency, or domain expertise — boundaries for converting their intent into production-quality applications.

This standardization means compliance teams can certify the output once — not re-audit every pull request. Teams can repurpose a single language-agnostic intermediate markup to target multiple platforms. A junior developer produces the same reliable markup as a senior architect because the architecture defines and controls the variability across the organization.

Constraining the AI to a validated pattern library mitigates security vulnerabilities. It reduces technical debt because the generated code follows consistent, maintainable architecture. By generating compact markup instead of verbose code, it reduces token cost and latency. Auditability and compliance are simplified because the deterministic layer produces traceable, repeatable artifacts.

Companies are adding AI capabilities at a staggering rate. In 2025, 84% of developers report using AI coding tools, with over half relying on them daily. Companies surveyed by Deloitte reported broadened worker access to AI by 50% in just one year. And 74% of companies said they plan to deploy agentic AI within two years.

Seventy-two percent of developers who have tried AI coding tools now use them every day. They report that 42% of the code they commit these days is AI-generated or assisted, according to a Sonar survey.

The rise of generative AI introduced extraordinary capabilities, but it’s not just a matter of accepting AI’s non-determinism as the cost of doing business. Deterministic boundaries — systems where AI takes human intent to structured specification, and proven code generators complete the journey from specification to production code — can make AI adoption safe, scalable, and accessible to every developer out of the box.

 

FAQs

  1. What are the key differences between agentic AI and generative AI?
    Answer: Generative AI focuses on creating content such as text, code, or images in response to prompts. Agentic AI goes a step further by reasoning, planning, making decisions, and executing multi-step tasks to achieve a goal. While generative AI produces outputs, agentic AI can orchestrate workflows and interact with tools, APIs, and enterprise systems. For enterprise software development, combining agentic AI with deterministic engineering guardrails helps organizations achieve both productivity and predictable outcomes.
  2. What are the benefits of hybrid AI architecture compared to traditional AI models?
    Answer: Hybrid AI architectures combine the reasoning capabilities of large language models with deterministic software engineering. Instead of allowing AI to generate production code directly, the AI first creates a structured specification, which is then converted into production-ready code by a deterministic engine. This approach reduces hallucinations, improves security, enables repeatable outputs, lowers token costs, and supports enterprise governance while preserving AI's speed and flexibility.
  3. What are the best agentic AI tools available today?
    Answer: The best agentic AI tools depend on your use case. Developer-focused platforms like Cursor, Claude Code, Codex, and Replit accelerate coding, while enterprise platforms such as WaveMaker combine AI agents with deterministic code generation, architecture guardrails, design systems, and governance to deliver production-ready enterprise applications. Organizations should evaluate tools based on reliability, security, maintainability, integration capabilities, and long-term code ownership.

 

This blog is originally published on Techstrong.ai

The 2-Pass Compiler Is Back—This Time, It’s Fixing AI Code Gen

How a battle-tested compiler architecture from the ‘70s solves the reliability crisis in LLMgenerated code.

If you came up building software in the ’90s or early 2000s, you remember the visceral satisfaction of determinism. You wrote code. The compiler analyzed it, optimized it, and emitted precisely the machine instructions you expected. Same input, same output. Every single time. There was an engineering rigor to it that shaped how an entire generation thought about building systems.

Then LLMs arrived and, almost overnight, code generation became a stochastic process. Prompt an AI model twice with identical inputs and you’ll get structurally different outputs. Sometimes brilliant, sometimes subtly broken, occasionally hallucinated beyond repair. For quick prototyping that’s fine. For enterprise-grade software—the kind where a misplaced null check costs you a production outage at 2 AM—it’s a non-starter.

We stared at this problem for a while. And then something clicked. It felt familiar, like a pattern we’d encountered before, buried somewhere in our CS fundamentals. Then it hit us: the 2-pass compiler.

 

A Quick Refresher

Early compilers were single-pass: read source, emit machine code, hope for the best. They were fast but brittle—limited optimization, poor error handling, fragile output. The industry’s answer was the multi-pass compiler, and it fundamentally changed how we build languages. The first pass analyzes, parses, and produces an intermediate representation (IR). The second pass optimizes and generates the final target code. This separation of concerns is what gave us C, C++, Java—and frankly, modern software engineering as we know it.

 

 

The analogy to AI code generation is almost eerily direct. Today’s LLM-based tools are, architecturally, single-pass compilers. You feed in a prompt, the model generates code, and you get whatever comes out the other end. The quality ceiling is the model itself. There’s no intermediate analysis, no optimization pass, no structural validation. It’s 1970s compiler design with 2020s marketing.

 

Applying The 2-pass Model To AI Code Gen

Here’s where it gets interesting. What if, instead of asking an LLM to go from prompt to production code in one shot, you split the process into two architecturally distinct passes—just like the compilers that built our industry?

Pass 1 is where the LLM does what LLMs are genuinely good at: understanding intent, decomposing design, and reasoning about structure. The model analyzes the design spec, identifies components, maps APIs, resolves layout semantics—and emits an intermediate representation. Not HTML. Not Angular or React. A well-defined meta-language markup that captures what needs to be built without committing to how.

This is critical. By constraining the LLM’s output to a structured meta-language rather than raw framework code, you eliminate entire categories of failure. The model can’t inject malformed <script> tags if it’s not emitting HTML. It can’t hallucinate nonexistent React hooks if it’s outputting component descriptors. You’ve reduced the stochastic surface area dramatically.

Pass 2 is entirely deterministic. A platform-level code generator—no LLM involved—takes that validated intermediate markup and emits production-grade Angular, React, or React Native code. This is the pass that plugs in battle-tested libraries, enforces security patterns, and applies framework-specific optimizations. Same IR in, same code out. Every time.

First pass gives you speed. Second pass gives you reliability. The separation of concerns is what makes it work.

 

Why This Matters Now

The advantages of this architecture compound in exactly the ways that matter for enterprise development. The meta-language IR becomes your durable context for iterative development— you’re not re-prompting the LLM from scratch every time you refine a component. Security concerns like script injection and SQL injection are structurally eliminated, not patched after the fact. Hallucinated properties and tokens get caught and stripped at the IR boundary before they ever reach generated code. And because Pass 2 is deterministic, you get reproducible, auditable, deployable output.

 

 

If you’ve spent your career building systems where correctness isn’t optional, this should resonate. The industry spent decades learning that single-pass compilation couldn’t produce reliable software at scale. The 2-pass architecture wasn’t just an optimization—it was an engineering philosophy: separate understanding from generation, validate before you emit, and never let a single phase carry the entire burden of correctness.

We’re at the same inflection point with AI code generation right now. The models are powerful. The architecture around them has been naive. The fix isn’t to wait for a smarter model. It’s to apply the engineering discipline we’ve always known, and build systems where stochastic brilliance and deterministic reliability each do what they do best—in the right pass, at the right time.

Deterministic software engineering is cool again. Turns out it never really left.

 

This blog is originally published on Infoworld.

Sure Coding, Not Vibe Coding: Speed Meets Certainty

Artificial intelligence is transforming software development. In the past two years alone, AI coding assistants have truly become mainstream, attracting millions of users and also significant venture capital. AI tools generate code from natural language prompts, accelerating development cycles, reducing repetitive tasks, and broadening access to programming. As AI adoption moves beyond experimentation, engineering teams are having more measured discussions. The industry is distinguishing between “vibe coding” characterized by fast, promptdriven AI output and the enterprise need for reliable, governed, and reproducible software development. Organizations are now prioritizing a new form of AI coding, one that can be termed “sure coding”.

 

Growing Pains

AI coding assistants have scaled rapidly. Vendors of developer copilots and automated coding environments report quick user adoption along with rising revenues, making these tools among the fastest-growing categories in enterprise software. The appeal is obvious. Developers and non-developers can build applications in minutes and deploy them almost instantly, exploring and navigating unfamiliar frameworks and coding languages without knowledge or expertise or architectural oversight. For many startups and smaller outfits, these capabilities often translate directly into productivity gains.

Yet, widespread use has also brought up several limitations. Engineering communities have highlighted concerns about uneven code quality, increased review workloads, and output that varies from one generation to the next. Non-deterministic behavior can make debugging difficult when generated code cannot be reliably reproduced. In production environments, where traceability and accountability matter, unpredictability introduces risk.

What has been discovered is that rather than eliminating work, AI-generated code is shifting it downstream. Developers frequently report spending additional time validating, refactoring, or rewriting generated output to align with internal standards. These challenges can be considered failures of the technology or maybe they reflect a mismatch between tools optimized for rapid experimentation and the realities of enterprise software engineering.

 

The Economics Behind

Alongside technical questions, economic concerns are also shaping these enterprise evaluations. Most AI coding platforms rely on large language models, with pricing based on usage. That dependency introduces uncertainty around long-term margins, pricing stability and the differences inherent in vendors. If model providers expand their own developer tooling ecosystems, competing platforms could face strategic pressure.

For enterprise buyers, this dynamic raises practical questions: How predictable are costs at scale? How portable are workflows between tools? And how resilient are development pipelines when critical capabilities depend on external model access? These considerations are pushing organizations to look beyond feature demonstrations toward sustainable operating models.

 

From Experimentation to Integration

The next phase of AI coding adoption appears less focused on sheer generation capability and more on integration with existing engineering workflows.

Large enterprises rarely build software from scratch. Their systems evolve over years through frameworks, compliance controls and architectural standards. These structures exist to ensure security, reliability and maintainability across distributed teams and uses. Tools that bypass these layers may accelerate early development but risk introducing technical mismatches or inconsistencies later. As a result, many CIOs and engineering leaders are cautious about extending AI coding tools into critical production environments. Instead, buyers increasingly prioritize platforms that align with established software lifecycle practices, such as specification-driven development, enforced review processes and traceability as well as architectural governance.

AI code-generation tools have been the rage throughout 2025 and early 2026, attracting millions of users and driving extraordinary growth. But initial euphoria is giving way to practical concerns around code quality, maintainability, and non-deterministic outcomes. Sustained adoption in enterprises will depend on guardrails, governance and alignment with architecture, not just generation speed.

The next generation of AI development tools will embed architectural awareness directly into developer workflows, guiding engineers along a garden path rather than freeform prompting.

 

Architecture: The New Differentiator

This emerging emphasis points toward what some industry observers call “architectural intelligence” – AI systems that understand not just how to write code, but how that code fits into broader enterprise structures. These systems aim to encode modern architectural standards, organizational rules, enforce approved patterns, and automatically ensure generated code conforms to internal benchmarks. Instead of replacing the engineering discipline, AI becomes a mechanism for scaling it consistently across teams. The distinction matters because enterprise software success depends less on writing individual functions quickly and more on maintaining coherent systems over time. Governance, documentation, and reproducibility are as critical as velocity.

AI tools that encourage informal experimentation may be valuable for prototyping and individual productivity. But enterprise adoption requires predictability, that is, the ability to produce the same results under certain conditions, audited against known standards.

 

Evolution of Developer Roles

Early narratives positioned AI as an autonomous coder capable of replacing significant portions of programming work. In practice, organizations are discovering that effective use requires experienced engineers who can define specifications, validate outputs, and integrate generated code responsibly. Rather than eliminating developers, AI is strengthening the importance of software architecture and system design skills. Developers increasingly act as orchestrators where they define intent, constraints and context, while AI helps by accelerating implementation within those boundaries. The result is a shift back toward structured collaboration between human expertise and machine-generated content, where the human leads.

 

From Vibe to Sure Coding

The history of enterprise technology adoption follows a familiar pattern. First there is excitement, followed by reassessment and ultimately stabilization around practical value. AI coding tools appear to be entering that middle phase. The conversation is shifting from how quickly code can be generated to how safely, consistently, and economically it can be deployed. As organizations move from pilots to production, success will likely depend less on creative prompting and more on disciplined integration. The future of AI-assisted code development may not belong to vibe coding at all, but to sure coding, where speed and certainty finally converge.

WaveMaker AI: predictable AI for UI-heavy, enterprise-grade app delivery

AI coding tools are everywhere now - and they are genuinely useful. But if you are responsible for shipping UI-heavy, highly customized, secure apps across multiple teams, you have probably hit the same wall:

WaveMaker AI pairs AI with a standards-driven platform that aligns teams on technology stack, design systems, best practices, reusability, and integration with existing SDLC processes.

 

What WaveMaker AI optimizes for

WaveMaker is for teams building multi-platform applications where UI complexity is not a side quest- it is the job:

WaveMaker AI advances the platform in three areas designed to accelerate large teams:

 

Three acceleration pillars in WaveMaker AI

 

1) Design-to-code automation that starts with your Design System

WaveMaker Autocode converts Figma designs into application artifacts using AI by generating a comprehensive set of design tokens mapped to the WaveMaker UI component library.

AI identifies components in Figma and maps them to corresponding WaveMaker UI components. The WaveMaker UI library has evolved to support complex customization, security, accessibility, and modern UI expectations.

Output targets Angular and React for web, and React Native for mobile.

WaveMaker UI Kit is enterprise-grade and built on Material Design principles. By default, components adhere to Material 3, while design tokens allow teams to adapt the look-and-feel to match their own design system.

 

Why fidelity and reliability improve: the 2-pass technique

WaveMaker uses a 2-pass generation technique designed to make conversion predictable:

This avoids betting everything on a single one-shot generation. A structured intermediate representation makes the system more controllable, repeatable, and easier to evolve.

 

2) Developer agents for real app workflows - not just code snippets

WaveMaker AI Agents accelerate workflows while reducing the burden on developers to manage the nuances of underlying UI frameworks, app architecture, or LLM prompting strategies.

Using plain-language prompts, WaveMaker agents help generate capabilities like:

 

Predictable output comes from structure, not vibes

WaveMaker agents generate predictable results by using the same 2-pass approach:

WaveMaker also provides a flexible agent framework so organizations can create custom agents tailored to their own use cases, standards, and scenarios.

 

3) WYSIWYG Studio: human-in-the-loop control that scales across teams

WML does not just help AI generate code - it also powers WaveMaker Studio: visual layout creation, drag-and-drop authoring, and fine-grained control over look-and-feel.

This matters when you are using automation heavily. AI is great at proposing; teams still need a fast way to validate visually, course-correct quickly, and collaborate across stakeholders.

WaveMaker Studio supports a large-team environment with integrations across enterprise tooling, including:

It is a full workflow environment - not a bolt-on chat box.

 

How WaveMaker AI stacks up in an AI dev-tool world

Tools like Cursor, Claude Code, Codex, Replit, Cline, Augment Code, and v0 are pushing the space forward. They are excellent at accelerating individual developers and speeding up prototyping and coding loops.

WaveMaker AI is optimized for a different problem: shipping consistent, design-governed, multi-platform applications across large teams.

Where general-purpose AI coding tools often struggle is where WaveMaker anchors its approach:

If your bottleneck is a single developer coding faster, copilots are great. If your bottleneck is 10 squads shipping coherent UI plus integrations every release, WaveMaker AI is built for that.

 

The direction forward: AI is not the product - architecture is

In the AI era, prompt-to-code alone does not solve modern application development. Teams need a stronger foundation in architecture that scales, design principles that enforce consistency, open standards-based output, abstractions that reduce skill bottlenecks, and workflows that fit real enterprise SDLC.

WaveMaker AI applies AI where it accelerates, structure where it matters, and control where teams need it.

 

Is AI generated code ready for enterprise adoption?

Developer productivity, adoption & challenges with AI generated code

 

 

The growing popularity of vibe coding platforms has led to more LLM usage for code creation, potentially to accelerate app development. The start of 2025 saw a boom in vibe coding platforms, like Loveable, Vercel v0, Bolt, Replit, Kiro, Base44, etc., which simplified developer processes, enabled web app creation, and promised comprehensive app development. However, the quality and consistency of the code generated is highly debated, leading to roadblocks for developer adoption.

The hype!

 

Anyone can become a programmer

Today, LLMs have evolved to accurately generate programming language syntax, best practices, and well-defined code solutions. Yes, with a well-guided problem statement and appropriate application context, they understand known trends in app architecture and produce meaningful framework code.

Vibe coding platforms produce a lot of code, which is good for bootstrapping an app prototype. But, as you start to iterate and try to make things work, it feels like you are making one step forward and two steps backward (quoted as ‘two steps back pattern’ in the article The 70% problem: Hard truths about AI-assisted coding by Addy Osmani). One needs to be a programmer to review, debug and validate the code generated by these AI code gen tools.

Not all working code is secure and reliable. To validate and accept code suggestions, you need to be a real programmer and that’s the catch!

 

Complete app development using simple prompts

LLM context window sizes are increasing, evolving to solve large problems and generate considerable portions of apps with layers of complex framework related artifacts, code and dependent libraries. Vibe coding platforms are leveraging these recent LLM improvements to generate entire app scaffolding with business logic to create web apps, based on frameworks like React, Next.js, Node.js, etc.

Vibe coding platforms index and store portions of codebase, so that the vibe coder can express ‘intent’ in plain text (English for now) and the underlying system retrieves and submits these code snippets as context to the LLM for feature generation. This is a very important process and a lot of code and prompt text gets transmitted back and forth between the LLM and the code editor.

Tokens = Syntactical strings ~ (code + prompt text + knowledge base [code examples, tools]) LLMs consume a lot of tokens to generate the code that you desire.

In reality, only simple features gets built with simple prompts and anything complex will need more context and have to go through several iterations. Even after these iterations, chances are high that one needs to end up debugging the code, by askingthe LLM to explain and identify what’s missing!

 

Super cheap alternative to hiring and building large dev teams

Any complex application development requires a lot of planning, documenting, decisions made regarding architecture, technology stack and developer skillset. LLMs today have matured and are good at automating development tasks such as:

  1. Bootstrapping boiler plate code
  2. Documenting code snippets
  3. Identifying architectural flows
  4. Enforcing coding best practices
  5. Generating well-defined code solutions
  6. Identifying bugs
  7. Generating test cases etc.

However, a team of professionals are needed with in-depth understanding of organization’s needs, domain expertise, ability to understand legacy architectures and appropriate experience to make the right technology and architectural choices. LLMs can only handle automation of certain development tasks only after a strong foundation is laid by experienced developers. Hence, it is not yet viable to build core applications and systems with a bunch of junior developers or non-tech folks assisted by LLMs.

App generation with LLMs today is token frenzy, millions and billions of tokens are needed to build anything practical and it is a very expensive affair at scale! The budgets for large teams are unchecked due to the unpredictable costs and exponential increase as the size of the codebase or the number of developers go up. For a team size of 10-25 developers, monthly AI coding tools alone could cost an additional $75k more per month (as per this article ‘ What a CTO must budget for AI coding tools‘). In reality, both the developer skillset needed and the costs are not dramatically reduced by using AI.

 

The implications of AI code generation on developer productivity

The unpredictability brought by vibe coding platforms makes it difficult for big organizations and large development teams to adopt AI with the objective of reducing costs or accelerating time to market. However, LLM coding assistance tools like Cursor, Github copilot, Claude Code etc. are well adopted by experienced developers, where they control and govern the output generated by these tools before it is pushed to production.

Coding assistance tools differ from vibe coding platforms in the following aspects, they are:

However, the following are some of the challenges faced by developers who have adopted code assistance tools:

  1. AI hallucinations & non-deterministic output makes developers spend more time debugging
  2. AI generated code is hard to refine through iterations
  3. As the codebase grows, AI makes incomplete suggestions and truncated output
  4. False sense of security and disregard for performance

 

1. Developers spend more time debugging

One of the challenges with AI is deterministic output and developers are using several mitigation strategies with prompts, context refinement with appropriate code examples, RAG (Retrieval Augmented Generation) based frameworks and guardrails to make the LLM generate consistent output. While some of the development teams who are on a higher maturity curve for AI adoption have figured out these approaches to improve the quality of AI generated code, it is not practical for everyone to adopt and succeed with similar approaches.

A recent report published by harness.io ( Beyond CodeGen: The role of AI in the SDLC), states that 67% of the developers spend more time debugging AI generated code. As this generated code could include outdated dependencies and insecure coding patterns that requires developers to spend more time identifying these problems. While there is initial acceleration, the time it takes to identify and address such problems in AI generated code is a serious setback to developer productivity.

 

2. Hard to refine AI generated code through iterations

Building a typical code solution in traditional coding approach starts with creating an initial working prototype version and then developers rewrite and refactor this version to adhere to architecture best practices of the organization, security needs, readability and maintainability for upgrades. With AI code generators, developers have a slightly better and faster start, but inevitably they need to iterate with prompts to make it accurate.

AI generates different output in every iterative step making it harder for developers to keep track of changes. Any customizations made previously gets overwritten during iterations, leading to lack of control over code generation. As the feature development progresses and after a few prompt iterations, previously working capabilities could start to fail leading to developer’s frustration and a lot of rework.

 

3. Inaccurate and incomplete code suggestions

As the size of the codebase increases, the code suggestions are inconsistent for developers to accept. This is largely attributed to limited LLM context window available and developer’s ability to optimize context with approaches leveraging code indexing, other RAG techniques, MCP Servers etc. More compute is needed as the context size increases and LLMs have usage limits and restrictions, resulting in improper output or increased response times.

Today’s LLM architectures, context window and caching techniques are not suitable for large codebases. While MCP (Model Context Protocol) addressed the ability for LLM to retrieve additional context to accurately produce code, it has also increased the complexity around developer tooling.

 

4. False sense of security and disregard for performance

“A human sees a suspicious URL; an AI sees valid syntax. And that semantic gap becomes a security gap”, by Bruce Schneier - a renowned security expert.

 

 

Veracode Gen AI code security report states 45% of the code generated by LLMs have known security flaws, which are identified during vulnerability assessment checks. This is because of the training data on which LLMs are trained i.e. publicly available source repositories and possibly containing vulnerabilities. Another hypothesis is most of the secure implementations and better training examples are not in public repositories and RLHF method for training the models with all possible secure scenarios may not be feasible.

Generating performant code requires deeper understanding and systems-level thinking, which requires a lot more compute. LLMs are as good as their training scenarios and the chances that they are trained on complex use cases and a widespectrum of niche scenarios is unknown. AI report from harness.io hints 52% of the time performance problems are reported in AI generated code.

 

Conclusion, What’s the road ahead?

AI code gen platforms, AI model providers, tech community and investors are all very bullish about the AI coder dream, but the reality is far from true. While the advancements in LLM technology and the quality of AI generated code is constantly improving over time and becoming adaptable, a human-first approach is needed to build reliable app solutions today.

Developers have to be more cautious with AI generated code and employ more checks and balances in their development environment, such as:

AI code generation platforms need to be more than just glorified prompt wrappers with smart developer interfaces, they need to tackle real challenges in buildingapplication solutions in terms of security, reusability, customizability and scalability. These platforms should focus on reducing the skillset needed to work with AI generated code and enable a human-first approach for developers to stay in control and succeed.

The future of app development is going to be very exciting with mature AI code generation solving skill reduction, time to market and building complex use cases. Development teams will be able to lean towards AI coding platforms to solve technology debt, time taken to address security vulnerabilities and building scalable enterprise-grade solutions with more confidence.

Design-First Sizzle Comes to (Boring) Enterprise Applications

The apps we use at work are finally catching up to the ones we love on our phones. Here's why that matters more than you think.

Something odd has been happening inside large enterprises. The same companies that run multibillion-dollar operations on software that looks like it was last updated during the Bush administration are suddenly rolling out internal tools that wouldn’t look out of place on your iPhone. Dashboards with elegant typography. Onboarding f lows with real delight. Partner portals that make you want to bookmark them. The boring enterprise application — that clunky, soul-draining workhorse of corporate life — is getting a makeover. And the makeover is permanent.

This isn’t a coincidence. It’s a convergence. The consumer mobile revolution trained all of us — every employee, every executive, every customer — to expect software that is intuitive, beautiful, and fast. We swipe through Airbnb listings on Sunday and then open a procurement system on Monday that looks like it was designed by a committeein 1998. The cognitive dissonance became unbearable. And now, thanks to a new generation of design tools and AI-powered platforms, the gap is closing at a speed that would have seemed impossible even three years ago.

 

The Expectation That Changed Everything

Let’s be honest about what happened. The smartphone didn’t just give us a portable computer — it rewired our expectations for every piece of software we touch. Instagram taught us that interfaces should be frictionless. Uber taught us that complexity can be invisible. Notion and Slack proved that tools built for work could feel just as polished as tools built for play.

That shift in expectation didn’t stay in our personal lives. It walked through the office door. Employees started asking uncomfortable questions: why does the app I use to order lunch feel ten years ahead of the one I use to submit a purchase order? Why does our customer portal look like a relic when our competitor’s looks like it was designed yesterday?

Building products for people to use at work shouldn’t be an excuse for bad design. The distinction between designing for consumer and enterprise has rapidly narrowed.

— Amanda Linden, former Head of Design at Asana

These aren’t trivial complaints. They point to a real business problem. When enterprise tools are ugly, confusing, or inconsistent, employees resist them. Training costs balloon. Support tickets pile up. Adoption stalls. And in a world where digital tools are the primary medium through which work happens, that friction is no longer an inconvenience — it’s a competitive liability.

 

AI Hands the Enterprise a New Starting Point

Here’s where the story gets interesting. For most of enterprise software history, the design phase was an afterthought. Engineers built the functionality. Then, if the budget allowed, someone applied a coat of visual polish. The result was predictable: capable software that nobody enjoyed using.

That sequence has been inverted. Today, AI-powered tools like Lovable let teams describe an application in plain language and receive a fully functional, consumergrade prototype in minutes — not months. The very first thing a stakeholder sees is a beautiful, interactive, working application. Design is no longer the last coat of paint. It’s the first brick.

95% of Fortune 500 companies use Figma

$749M Figma revenue in 2024 (+48% YoY)

13M+ monthly active users on Figma

And then, in November 2025, something happened that crystallized the trend. ServiceNow and Figma announced a strategic integration that lets teams use a Figma design file as a direct prompt to an AI agent that generates a secure, scalable enterprise application. Not a mockup. Not a prototype. A working application — in minutes. Design intent becomes production code without the traditional handoff that used to dilute quality at every stage.

Figma’s CTO captured it perfectly: in a world of AI-generated software, design is the differentiator that will make your product stand out. When anyone can spin up functional code with a prompt, the thing that separates good from forgettable is taste. Craft. The intentionality of the experience.

 

Design Systems: The Quiet Infrastructure Revolution

Behind the scenes, a less flashy but equally important transformation is underway. Enterprises are investing in design systems — the component libraries, tokens, and style guidelines that ensure consistency across every screen, every product, and every team. This is the plumbing that makes the polish sustainable.

Figma is at the center of this. Two-thirds of its user base are now non-designers — product managers, engineers, marketers — which tells you something profound about where design is headed. It’s no longer a specialized function sequestered in a creative department. It’s an organizational capability. Headspace reports 20 to 50 percent time savings through design tokens. Swiggy cut feature rollout time in half by tracking design system adoption rigorously.

Here’s the crucial insight: design systems don’t just make software look good — they make the entire development process faster and cheaper. They reduce duplicated work across teams, enforce brand consistency without manual policing, and provide the constraint set that AI tools need to generate on-brand interfaces automatically. Design infrastructure is becoming as essential as cloud infrastructure.

 

Design as the Signal, Not the Garnish

There’s a deeper strategic play here that goes beyond efficiency metrics. Enterprises are discovering that the design quality of their software sends a powerful signal — to employees, customers, suppliers, and partners — about who they are and where they’re headed.

Think about it this way. When a company deploys a beautifully designed internal tool, it tells employees: we value your daily experience. When a customer logs into a partner portal that feels as refined as the best consumer apps, it tells them: we are modern,competent, and invested in this relationship. When a supplier interacts with a procurement platform that is actually pleasant to use, it tells them: we operate at a different level.

Companies undergoing brand transformations or strategic pivots are increasingly leading with design. Not with press releases or ad campaigns — with the actual digital products that stakeholders touch every day. A redesigned enterprise application isn’t just a better tool. It’s a statement of intent.

In a competitive market, polished enterprise tools signal a business values its stakeholders, whether they are customers or partners or employees. Clunky, outdated applications signal stagnation. Design has become an unspoken part of stakeholder branding.

 

Where This Goes Next

The trajectory is clear. Enterprise applications will continue converging with consumer-grade quality, driven by three forces that are only accelerating.

First, AI will get better at generating interfaces that are not just functional but genuinely thoughtful — pulling from organizational design systems to produce screens that feel crafted, not generated. Second, the tools that bridge design and engineering will keep tightening. The ServiceNow-Figma integration is just the opening act; expect every major enterprise platform to build similar pipelines. Third, the people building enterprise software are changing. When two-thirds of your design platform’s users aren’t designers, the cultural expectation shifts: everyone becomes a stakeholder in experience quality.

$626B projected enterprise app market by 2030

34% faster task completion with design systems

50% rollout time cut at Swiggy via design tracking

The global enterprise application market is projected to nearly double by 2030, growing from $320 billion to $626 billion. Within that expanding arena, the organizations that treat design as a strategic priority — not an aesthetic afterthought — will build software that people choose to use, not software people are compelled to endure.

The boring enterprise application had a good run. For decades, it traded on necessity: employees used it because they had to, not because they wanted to. That era is ending. The tools exist. The expectations are set. The business case is proven. The only question left is whether your organization will lead this shift — or be the one whose software still feels like 2008 while the competition looks like 2028.

Design-first isn’t a trend. It’s the new minimum.

 

This blog is originally published on Substack