Stable Core, Vibe-Coded Surface

AI has made software dramatically easier to create.

That does not mean enterprise architecture should become casual.

The opposite conclusion makes more sense.

As the cost of creating interfaces, workflows and internal applications falls, organizations will produce far more software. Teams will build dashboards for temporary initiatives. Departments will create narrow utilities around local processes. Customer-facing portals will adapt to individual segments. Internal tools may exist for months rather than years. AI will increasingly generate pieces of the user experience around a specific task.

Software at the surface will become more disposable.

The core underneath it must become more stable.

This distinction matters because enthusiasm around vibe coding often collapses two very different activities into one category: creating an experience and defining organizational truth.

Those activities carry completely different risks.

• A team can safely regenerate a project dashboard if the dashboard only reads from governed systems. A team cannot safely regenerate the business rules that determine contractual status every time somebody changes the interface.
• A generated approval form can disappear tomorrow. The authorization model behind the approval cannot.
• A temporary client portal can change every week. The source of truth for project obligations cannot.
• A new AI interface can present information differently for each user. The identities, permissions, audit records and underlying data contracts must remain consistent.

The enterprise therefore needs a stable core and a flexible surface.

The stable core contains capabilities that the organization cannot afford to reinterpret casually: identity, authorization, canonical business entities, financial rules, contractual rules, audit history, approved data models, validated write operations, event definitions, system-of-record boundaries, security controls and versioned APIs.

The surface contains experiences that can change much faster: dashboards, task views, internal forms, workflow utilities, client portals, reporting interfaces, temporary operational tools, conversational experiences, AI-generated applications and role-specific interfaces.

This architecture turns vibe coding from a governance problem into a productivity advantage.

Without stable boundaries, easier software creation produces application sprawl. Every team can create another database, another representation of a customer, another workflow state and another interpretation of the same rule. Development becomes faster while the organization becomes less coherent.

That is not progress.

With stable boundaries, the economics change completely.

Teams can create highly specific software without recreating the enterprise underneath it. A new application can call the same customer API, project API, permissions service and document capability that every other application uses. AI can generate the missing interface around a particular workflow while established systems retain authority.

The result combines the best properties of custom and off-the-shelf software.

Historically, custom software offered specificity but imposed high development and maintenance costs. SaaS offered stability and lower risk but forced organizations to accept somebody else's workflows. AI weakens that trade-off.

A stable capability layer allows an organization to keep core systems while generating more specific experiences around them.

A construction company, for example, may keep established systems for identity, documents, projects and finance. A commercial manager may still need a highly specific view that combines contract obligations, correspondence, approvals and upcoming risks. Building an entirely new platform would make little sense. Forcing the manager into five generic applications makes equally little sense.

A lightweight interface can assemble those governed capabilities into the exact workflow required.

The interface can change as the work changes. The core does not.

This is the deeper value of becoming API-first.

API-first should not mean adding APIs because modern architecture diagrams look cleaner. It should mean expressing important organizational capabilities through stable contracts that other software can safely use.

• A project should have a canonical representation.
• A contract should expose approved ways to retrieve obligations.
• A task should have defined state transitions.
• A customer record should have a clear source of truth.

An AI-generated tool should not need to understand the entire architecture before performing useful work. It should consume narrow, reliable capabilities with clear boundaries.

Those boundaries create safe handoff points.

Human teams decide what must remain governed. Software engineers encode those decisions into durable primitives. AI and local teams gain freedom above that layer.

This also changes the role of central IT and engineering.

The objective stops being control over every interface.

The objective becomes control over the parts that deserve control.

That distinction will matter because attempts to centrally approve every AI-generated internal tool will fail. The volume will become too high. The speed advantage will disappear. Teams will route around governance.

A better model governs data access, identity, business rules, write operations and auditability while allowing much more freedom in presentation and workflow composition.

The organization becomes strict underneath and flexible above.

That principle also improves vendor strategy.

SaaS products increasingly become capability providers rather than complete experiences. The CRM may remain the system of record for commercial data without dictating every interaction a salesperson has with that data. The ERP may remain authoritative for finance while custom applications present selected information in context. SharePoint may continue storing documents while other interfaces organize those documents around projects, risks or decisions.

The interface loses its monopoly over the system.

That is a significant change.

For two decades, enterprise software vendors bundled data, business logic and user experience together. AI makes the user-experience layer much easier to replace, adapt and personalize. Organizations should take advantage of that without destabilizing the underlying operating model.

Vibe-code the surface. Engineer the core.

Software can become cheap enough to throw away.

Organizational truth cannot.