Essays

The traditional Software Development Lifecycle (SDLC) assumes that software is principally a human-authored code artifact that moves through recognizable phases such as requirements, design, implementation, testing, deployment, and maintenance. That framing still describes much of contemporary practice, but it is becoming incomplete. Generative systems can now synthesize code, tests, documentation, and configurations directly from structured prompts, domain knowledge, and operational context. As implementation becomes cheaper and faster, the hardest work in software production shifts toward clarifying intent, curating domain knowledge, enforcing policy, verifying behavior, and sustaining accountability. This essay argues that software should increasingly be understood not simply as source code, but as executable behavior bounded by policy, data, and interfaces. It further argues that the software lifecycle should be reframed as a continuous process that transforms intent into verified runtime behavior. The proposed model, called the Intent-to-Verified-Behavior (IVB) lifecycle, is presented as a conceptual successor to code-centric SDLC thinking. The second article in this trilogy extends this argument into software architecture; the third applies it to customer-agent and service-agent ecosystems.

The first article in this trilogy argued that the software lifecycle is shifting from code-centric production toward the continuous transformation of intent into verified behavior. If that argument is correct, then software architecture must also be reinterpreted. Classical architecture focused on code-bearing concerns: services, components, interfaces, deployment topologies, and operational infrastructure. Those concerns remain essential, but they are no longer sufficient. AI-native systems rely increasingly on three additional concerns that cannot be treated as peripheral overlays: knowledge, policy, and intent. Knowledge supplies the formalized meaning that generation depends on. Policy constrains what generated behavior may do. Intent expresses what the system is meant to achieve and provides the basis for reconciliation when runtime behavior drifts. This essay traces the maturation of each of these concerns, proposes a Knowledge–Policy–Intent (KPI) reference architecture, and argues that architects must now design the informational and governance substrate through which behavior is generated, bounded, and continuously verified.

The first article in this trilogy argued that software is increasingly best understood as governed behavior rather than as a static code artifact. The second argued that knowledge, policy, and intent must therefore become first-class architectural concerns. This final article applies those claims to a broader interaction model for digital services. In the dominant model, enterprises collect customer data, define the rules of access, and orchestrate service fulfillment from their own systems of record. An alternative model is becoming thinkable: the customer is represented by a software agent that holds identifiers, credentials, data references, and consent policies, while enterprises expose service agents that advertise capabilities and negotiate within bounded scopes. This essay argues that the building blocks for such a model already exist across self-sovereign identity, verifiable credentials, personal data stores, purpose-bound authorization, multi-agent communication, and service choreography.