The software industry has reinvented itself several times over the past fifty years, and each transition fundamentally changed its economics.

In the mainframe era, software was tightly coupled to hardware and delivered by small groups of highly specialized engineers.

The personal computer revolution shifted software into packaged products, creating scale through distribution. The internet era then transformed software into continuously connected services, and the rise of cloud computing and software as a service (SaaS) changed the economic model again: infrastructure became elastic, deployment became continuous, and software evolved from a one-time purchase into a recurring subscription business.

Agile and DevOps accelerated delivery cycles further, reducing the cost of release and turning engineering velocity into a competitive advantage.

Today, agentic development represents another structural shift, but this time the disruption is not only in how software is delivered, but in how it is produced. AI agents are beginning to perform meaningful portions of the software lifecycle, although with varying degrees of maturity: coding, testing, and documentation are increasingly reliable, while more complex activities such as research, specification drafting, architecture generation, security validation, release orchestration, and operations remain less mature and more dependent on human oversight.

The economics therefore change from scaling primarily through headcount to scaling through reusable agent artifacts (e.g., prompts, skills and more, which will be introduced in the upcoming chapters), orchestration systems, and autonomous execution loops. Small teams equipped with strong agentic workflows can now operate at a throughput that previously required entire departments.

Needless to say, the cost of generating software is falling, and available evidence increasingly confirms the productivity gains. In a controlled study of 95 professional developers, those using GitHub Copilot completed a JavaScript coding task 55% faster than those working without it. In a separate enterprise study with Accenture, Copilot adoption was associated with an 8% increase in pull requests, a 15% increase in pull-request merge rates, and an 84% increase in successful builds.

Yet the work has not disappeared; it has moved. Faros AI's analysis of telemetry from 10,000 developers across 1,255 teams found that teams with high AI adoption completed 21% more tasks and merged 98% more pull requests (PRs), while pull-request review time increased by 91%. A related Faros analysis found that developers on high-adoption teams interacted with 47% more pull requests per day.

CodeRabbit's review of 470 open-source pull requests found that AI-authored changes contained an average of 10.83 issues per pull request, compared with 6.45 for human-only changes, approximately 1.7 times as many.

Meanwhile, Aikido Security's 2026 survey of 450 security and development practitioners found that 69% of organizations had identified vulnerabilities introduced by AI-generated code, while one in five had experienced a serious security incident linked to it.

Figure 1.1 summarizes this tension between faster software generation and the growing burden placed on review, quality, and security.

Figure 1.1: Productivity gains and quality trade-offs in AI-assisted software development

This pattern shows that software generation is cheap, but judgment is not. The natural consequence is that the main cost and value for producing software have now shifted upward toward governance, architecture, context engineering, and organizational knowledge encoded into AI agent assets. Software engineering is no longer optimized around typing code faster; it is increasingly optimized around designing systems that can reliably generate, validate, and evolve software on behalf of humans.

That is why the industry now needs a disciplined operating model that can make agentic software delivery reliable, repeatable, and economically scalable, as opposed to relying only on the increasingly popular idea of "vibe coding."

AI-assisted development has evolved rapidly from simple code completion to systems capable of planning, generating, testing, and deploying software with limited human intervention. This shift has made software creation faster, but it has also exposed a widening gap between rapid generation and the engineering discipline required for enterprise delivery.

This section traces the rise of vibe coding, explains why it works well for prototypes but breaks down at scale, and introduces steered agentic development as a more accountable model in which humans define the boundaries while agents execute within them.

What "vibe coding" actually is and where it came from

The shortest definition is the one Andrej Karpathy gave when he coined the term in February 2025: "you fully give in to the vibes, embrace exponentials, and forget that the code even exists. " However, to understand why that phrase resonated, it helps to look at the two-year evolution of AI coding tools. The first wave (what now feels like the "obsolete" generation) was conversational and relied heavily on copying and pasting. Developers prompted ChatGPT or Claude in a browser tab and manually transferred the output into their integrated development environment (IDE); meanwhile, GitHub Copilot provided line-by-line autocomplete. The human remained in the loop for every keystroke, with AI acting as a fast assistant rather than an author.

Vibe coding is what happened when that loop closed. A new class of products, including Replit Agent, Lovable, GitHub Spark, Bolt.new, and Vercel's v0, collapsed prompt, scaffold, run, and deploy into a single conversation. You describe an outcome ("a Stripe-checkout SaaS for dog-walkers, dark mode, Postgres backend"), and the platform writes the files, installs the dependencies, runs the build, hosts the preview, and offers a "fix it" button when something breaks. The user often never opens a file.

Below you can see an example of a one-iteration, vibe-coded game using Vercel's v0 (prompt: Create a snake game where the player controls a snake that grows longer as it eats food.):

Figure 1.2: AI-assisted Snake game generation in Vercel v0, showing the user prompt, chat session, live application preview, and generated backend code

You can also see the entire backend code block generated behind the scenes and ready to be further developed in a repository.

The traction has been extraordinary: Karpathy's original post drew 4.5M+ views; Lovable hit a $1.8B valuation and 2.3M users in under a year; Replit Agent reportedly drove a 10× annual recurring revenue (ARR) jump in 2025; and GitHub Spark was explicitly positioned as "from idea to deployed app in one prompt." By early 2026, 85% of professional developers used AI coding tools at least weekly, and 25% of Y Combinator's Winter 2025 batch had codebases that were 95% AI-generated. Figure 1.3 summarizes these product-growth and adoption indicators.

Figure 1.3: Product growth and ecosystem adoption indicators for AI-assisted coding tools

The cultural shift is real and worth taking seriously: people can now produce working software without closely reading much of the underlying code. That is precisely what makes the technique so productive for a weekend hack, an internal tool, or a throwaway prototype, and precisely what makes it risky when the same application must integrate with enterprise systems, pass a security audit, or be maintained years later.

The challenge is therefore not to abandon the speed of vibe coding, but to steer it: keeping humans accountable for the decisions that matter while letting agents execute everything else.

Why "vibe coding" works for prototypes and breaks at enterprise scale

The same quality that makes vibe coding feel incredible for a quick prototype is also what makes it risky at enterprise scale. You describe an outcome, the AI generates the application, and the feedback loop feels almost magical. For a weekend experiment or an internal demo, that speed can be transformative.

The problem begins when the software must survive beyond the original creator. Enterprise systems are reviewed by multiple teams, integrated with existing platforms, audited for security, maintained for years, and often operated by people who were never part of the original AI conversation. At that point, the shortcuts that made vibe coding fast begin to create friction.

Several predictable issues tend to appear:

• Ownership: Teams start relying on code they never fully understood. The application works, but nobody can clearly explain why certain decisions were made or how specific pieces interact.

  For example, a developer may generate an authentication workflow in minutes, but six months later, when login failures begin appearing in production at night, the support team struggles to debug it because the logic was never truly understood by the people maintaining it.

• Drift: Different developers using different prompts and AI sessions gradually produce inconsistent systems. Naming conventions drift, architectural patterns diverge, and duplicated logic spreads across repositories. Individually, the features work, but together the codebase starts feeling fragmented and harder to evolve.
• Security: AI-generated code can introduce vulnerabilities surprisingly quickly when guardrails are missing. Hard-coded secrets, insecure dependencies, excessive permissions, and unsafe patterns often make their way into production because teams move faster than their review processes can keep up.
• Invisible assumptions: Generated code often arrives without the surrounding engineering context: no clear specification, no documented tradeoffs, and no explanation of why a certain approach was chosen. That makes future refactoring, certification, onboarding, and audits much harder than they appear initially.

These problems rarely occur independently; they reinforce each other. Many organizations moving from experimentation into uncontrolled AI-assisted development follow a recognizable pattern:

1. Velocity spike: Teams suddenly produce features much faster, and delivery metrics improve dramatically.
2. Consistency erosion: Different coding patterns and duplicated logic begin appearing across projects.
3. Review fatigue: Pull requests become too large and too frequent for reviewers to properly validate.
4. Incident acceleration: Bugs, vulnerabilities, and architectural inconsistencies increasingly reach production.
5. Velocity collapse: Eventually the codebase becomes difficult to trust, and teams slow down again because every change requires rework, debugging, and stabilization.

Figure 1.4 illustrates how the initial increase in velocity can create a cycle that ultimately undermines that same velocity.

Figure 1.4: The vibe-coding flywheel, from an initial velocity spike to consistency erosion, review fatigue, incidents, and eventual slowdown

The lesson is not that AI-assisted development is bad. The lesson is that vibe coding is an excellent prototyping technique, but not, on its own, a sustainable enterprise delivery model. Without structure, governance, and shared engineering practices, short-term speed often turns into long-term operational cost and technical debt.

This is the point at which vibe coding must give way to steered agentic development, which we are going to explore in the next section.

From vibe to "steered": humans steer, agents execute

To understand what "steered" really means, it helps to step back from code for a moment and look at how the relationship between humans and AI has evolved in just three years. The first generation of large language models (LLMs), ChatGPT and its peers from late 2022, functioned primarily as tools: users entered a request, received a response, and decided what to do with it. By 2024 they had matured into assistants: persistent context, retrieval, function calling, and an increasing willingness to take small initiatives on the user's behalf. From mid-2025 onward, a third register appeared, captured in nearly every major industry survey of the year: agents that plan, use tools, and take multi-step actions. MIT Sloan and Boston Consulting Group (BCG)'s 2025 executive study found that 76% of leaders now describe agentic AI as collaborators or coworkers rather than passive tools. Microsoft's 2025 Work Trend Index goes further, naming the emerging organizational form a "frontier firm" in which "human-agent teams" are an everyday unit of work. In a frontier firm, agents are no longer asked to answer; they are asked to act, and acting requires the same accountability infrastructure we already extend to human colleagues: a role, a scope, a manager, and a paper trail. Figure 1.5 illustrates this progression from assistive AI tools to collaborative human-agent teams and orchestrated agentic workflows.

Figure 1.5: Evolution from assistive AI tools to collaborative human-agent teams and orchestrated agentic workflows

Software engineering is where this evolution appears most clearly, because the work is text-shaped, automatable, and instrumented end-to-end. The "coworker" that developers actually meet on a daily basis in 2026 wears several hats at once: a pair-programmer who finishes the line you're typing, a tireless junior developer who can take a ticket and produce a draft PR overnight, an on-call architect who can summarize a 200-file repository and propose a refactor, and an orchestrator that spawns sub-agents for tests, security scans, and documentation. GitHub's 2025 Octoverse describes this directly: the role of the senior engineer is shifting from "writer of code" to "director of code-writing systems." That sounds aspirational until you notice the management responsibilities it quietly imports. Directing a team, even a team of one human and three agents, means briefing it, scoping its work, reviewing its output, accepting risk on its behalf, and being able to explain afterwards why a decision was made. Vibe coding skips every one of those responsibilities. It treats the agent as a vending machine: insert prompt, receive feature, ship. That works for one developer and one weekend. It does not survive contact with a team of fifteen, an audit, or a postmortem.

Steered development puts those responsibilities back where they belong without giving up the speed that made vibe coding attractive. In practice, the move from vibe to steered development involves three shifts:

1. Delegation: Instead of assigning an open-ended outcome such as "build a checkout flow," the agent receives a bounded task with explicit inputs, permitted tools, allowed actions, and a definition of done.
2. Accountability: A named human owns the decision and approves the change, even when most of the implementation was generated by an agent.
3. Evidence: Every change includes the artifacts that a future engineer or auditor may need, such as a specification, tests, scan results, and a recorded rationale.

These shifts do not primarily require new technology. They require clear rules for how developers assign work to agents, review their output, and approve changes. These rules should be documented in the repository and enforced through the delivery pipeline.

Figure 1.6 represents this new relationship. Developers no longer execute every step manually, but instead steer networks of specialized agents across planning, coding, validation, and operations. Software development becomes less about typing code line by line, and more about orchestrating autonomous systems within human-defined boundaries, approvals, and governance.

Figure 1.6: A steered agentic development workflow across planning, coding, security, human approval, and operations

Before introducing the machinery that supports this model, there is a simple field test that tells you whether a given change is steered or merely vibed. Ask three questions about any AI-assisted change before it merges:

1. Who decided this? A named human with the authority to accept the risk.
2. What were the constraints? Coding standards, architectural boundaries, security and data-handling policies: explicit, not tribal.
3. What evidence proves it works? Tests, scans, traces, and a recorded rationale that another engineer (or auditor) can replay six months from now.

If you cannot answer all three for a given change, you are still vibe coding, regardless of how sophisticated the tooling looks. Steered development, in other words, is not an upgrade to the agent; it is the management contract you sign with it. Get that contract right and the rest of the booklet, including the primitives, the cadence, and the governance, is just the apparatus that makes the contract enforceable.

The industry needed a way to preserve the speed of vibe coding without inheriting its inconsistency, fragility, and governance gaps. Microsoft's answer is HVE: an AI-native delivery model in which small, multidisciplinary teams use AI agents, continuous automation, and a shared library of reusable primitives, such as instructions, prompts, skills, agents, and hooks, to build production-grade software at a pace that once required entire departments.

HVE does not treat AI simply as a productivity add-on. It reorganizes software engineering around agentic workflows, structured orchestration, and institutional knowledge encoded into reusable artifacts. Engineering capacity therefore scales not only by adding people, but by improving the quality and leverage of the underlying agentic system, allowing small teams to deliver faster without sacrificing governance, reliability, or quality.

The result is a delivery model where engineering capacity scales not linearly with headcount, but through the quality of the underlying agentic system, enabling organizations to ship production-ready solutions at a speed that would have been economically and operationally unrealistic only a few years ago.

The three foundations of HVE

Three ingredients give HVE its leverage. They are not individual products or tools, but organizational and engineering choices that reinforce one another:

• Small, multidisciplinary teams. HVE is delivered by compact units of roughly four to five people that combine engineering, product, and domain expertise in a single group. A smaller team creates tighter feedback loops, clearer ownership, and decisions made in hours rather than across multiple stand-ups. The team is the smallest unit capable of shipping a meaningful slice of value end-to-end that is intentional.
• Solution accelerators. Teams do not start from a blank repository. Microsoft provides curated accelerators, including proven architectures, reference implementations, and reusable building blocks distilled from a wide catalog of real AI solutions, so that common patterns are inherited rather than rediscovered. The accelerators carry the institutional memory of what has worked, which is what makes a one-week prototype a credible foundation for a production rollout.
• AI woven through the entire lifecycle. AI is embedded across the entire software development life cycle (SDLC), from early ideation and planning through coding, validation, and operations. Agents and tools take on the repetitive and well-defined work, such as generating tests, drafting documentation, running checks, and summarizing state, so that the human team can spend its time on judgment, design, and the decisions that genuinely require it.

The combination is what creates the velocity. Organizations applying HVE, including telecommunications leaders such as AT&T and KT Corporation, who are using the approach to modernize their development practices, are compressing AI delivery timelines from months or years down to weeks, while at the same time raising the bar on quality and maintainability.

In other words, HVE is what makes steered agentic delivery repeatable. It takes the speed that vibe coding hints at, pairs it with the structure that enterprise software requires, and gives small teams a credible operating model for shipping AI-powered systems at scale. Figure 1.7 shows how intent and engineering rules move through an HVE delivery system to produce structured, enterprise-ready software.

Figure 1.7: An HVE delivery workflow that transforms code and intent into enterprise-ready software through rules, agents, tools, and validation

In the next section, we are going to see how to assess your maturity level in the HVE journey as an enterprise.

The HVE maturity spectrum

Not every organization is starting from the same place. Before you can chart a course to HVE, you need an honest assessment of where you are today.

That's why we need to introduce a maturity model for HVE, which is a scale of progressive delegation, showing how organizations move from largely human-executed software delivery to increasingly agent-supported and AI-native engineering.

The HVE maturity model defines five distinct levels across the spectrum from traditional development to full AI-native engineering.

Each level is not merely about which tools you have purchased; it is about the discipline, methodology, and organizational design you have built around them.

• Level 1: Traditional development. There is no meaningful AI integration. Engineering relies entirely on human throughput, manual processes, and conventional tooling. Estimation is in story points; quality lives in pull request reviews; and capacity is a function of headcount. This is where most of the industry operated in 2024, and where a decreasing number of competitive organizations remain today.
• Level 2: AI-assisted (the autocomplete era). Individual developers use AI for code completion and snippet generation. Adoption is ad hoc: some engineers swear by it, others ignore it, and nobody has written a policy either way. The productivity gains are real but modest, and they come with hidden risk, because there are no shared standards for how AI-generated output is reviewed, governed, or measured. The organization has purchased the tool but it has not yet adopted the methodology.
• Level 3: Vibe coding. This is where things get dangerous. Teams are actively using AI for generation, and the velocity feels impressive. First drafts appear in minutes. Features seem to materialize overnight; however, the discipline is missing. Prompt strategies are personal, not institutional. Quality is inconsistent. Architecture decisions are being made by the model, not by the engineer. Therefore, technical debt is accumulating invisibly: hallucinated dependencies, unownable output, undocumented assumptions baked into generated code that nobody reviewed because it looked correct. Vibe coding can be an appealing stage to remain in because of its immediate productivity gains, but without stronger discipline, it may also become the most costly.
• Level 4: Structured agentic development. The organization has learned that speed without structure creates more work later. Teams no longer ask AI to "build the feature" and hope for the best. They begin by having agents inspect the codebase, gather context, surface assumptions, and propose a plan before any code is changed. Engineers review that plan, define the boundaries, and decide which steps can proceed autonomously and which still require approval.

  Daily work starts to look different. Sprint planning includes not only who will do the work, but what can be delegated to agents, what evidence they must produce, and where a human must intervene. Coding standards and architectural guidance are written into files the agents can read, while recurring tasks such as test generation, documentation, code review, and security checks are gradually turned into reusable workflows. The main concern is no longer whether developers are using AI, but whether every team is using it with the same discipline. Some groups operate this way consistently; others still fall back into improvisation when deadlines tighten. The methodology exists, but it has not yet become the organization's default behavior.

• Level 5: HVE. At this level, agentic development is no longer a special initiative. It is simply how engineering work gets done. A small team can oversee several streams of work in parallel because agents handle much of the repetitive exploration, implementation, testing, documentation, and validation. Engineers spend less time producing every artifact themselves and more time defining intent, making architectural decisions, resolving ambiguity, reviewing evidence, and deciding when the system is ready to move forward.

A typical day is less about issuing isolated prompts and more about steering a coordinated delivery system. Agents arrive at planning sessions with research already completed, proposed approaches, identified risks, and links to the evidence behind their recommendations. During implementation, they work within predefined boundaries, run checks continuously, and escalate when a decision exceeds their authority. Engineering managers spend less time chasing status updates and more time examining whether teams are solving the right problems, whether the quality bar is holding, and whether increased capacity is translating into measurable business value.

What often surprises teams at this stage is that human judgment becomes more important, not less. The work that remains is the work that cannot be safely reduced to repetition: choosing trade-offs, challenging assumptions, protecting coherence across the system, and deciding what should not be automated. The organization is not merely writing software faster; it has changed how capacity is created, how decisions are made, and how engineering value is measured.

Figure 1.8 presents the progression across the five maturity levels.

Figure 1.8: The five levels of the HVE maturity spectrum, from traditional development to HVE

Levels show your overall maturity; however, we still need to understand what to fix or change to move forward. In the next section, we are going to explain what actually drives that maturity.

The seven maturity dimensions

The maturity model assesses organizations across seven dimensions, each of which must advance for the organization to move to the next level:

1. AI tool adoption and integration: From no AI tooling to constrained, accountable AI collaborators embedded in every workflow.
2. Primitive stack maturity: From tribal knowledge and scattered documentation to a complete, version-controlled stack of instructions, agents, prompts, skills, and hooks.
3. Development methodology: From ad hoc "ask and see" to the disciplined Research → Plan → Implement loop applied universally.
4. Governance and security: From relying on human code review alone to continuous, automated policy enforcement embedded in the primitive stack.
5. Business value measurement: From unmeasured adoption to formal Business Value Assessments as first-class artifacts for every capability.

   Definition

   A Business Value Assessment is a structured evaluation of how a proposed capability contributes to measurable organizational outcomes, such as revenue, cost reduction, risk mitigation, efficiency, or customer experience. It makes expected value, assumptions, metrics, and trade-offs explicit so investment and prioritization decisions can be made consistently.

6. Team structure and capacity model: From headcount-based planning to capacity models based on primitive stack quality and team expertise.
7. Human-in-the-loop design: From undefined AI boundaries to explicitly designed autonomy scopes, escalation triggers, and audit trails for every agentic workflow.

Figure 1.9 maps the seven dimensions across the maturity spectrum, helping organizations identify the capabilities currently limiting their progress.

Figure 1.9: The seven dimensions used to assess HVE maturity and identify organizational bottlenecks

The companion assessment for this chapter (available at the book's GitHub repository) allows you to score your organization across all seven dimensions and receive a personalized improvement roadmap.

You can take the assessment at https://valentina-alto.github.io/Enterprise-Vibe-Coding-for-Agentic-AI/chapter1/index.html or by scanning the QR code below.

By the end of the assessment, you will also receive a customized prompt to pass to your LLM of choice (Claude, Copilot, ChatGPT, etc.) to get personalized recommendations on how to advance through the maturity model.

The maturity assessment identifies where an organization stands; the next step is to address the risks most likely to derail its progress.

Regardless of which stage you locate yourself in, three risks dominate every conversation with technology, engineering, and platform leaders in 2026. Use them as a quick triage checklist for the next 90 days.

1. Review-capacity collapse: AI-generated PR volume routinely outpaces reviewer scrutiny within months of rollout (Faros AI: +47% PRs, +91% review time). If your senior engineers are now full-time reviewers, you are already past the safe threshold. Mitigation preview: machine-checkable definition of done, evidence-in-PR, and review-agent pre-checks (Chapter 3).
2. Security and data drift: Secrets exposure, Open Worldwide Application Security Project (OWASP)-class vulnerabilities, and over-privileged tool access scale with AI adoption unless explicitly contained.

   Definition

   OWASP is a nonprofit foundation that develops open standards, tools, and guidance for identifying and preventing common software-security vulnerabilities.

   Mitigation preview: bounded autonomy, least-privilege Model Context Protocol (MCP) connectors, and policy-as-code (Chapter 5).

3. Invisible architectural drift: Different agents, sessions, and prompting approaches can gradually introduce conflicting patterns until the codebase no longer behaves like a coherent system. This risk may take longer to surface than the others and can be costly to reverse. Repository-level instructions and a small set of version-controlled skills and agents can help maintain consistency, as discussed in Chapter 3.

AI has made the initial generation of software faster and less costly, but review, integration, governance, security, and consistency remain critical challenges. Vibe coding can accelerate prototypes, but it becomes difficult to sustain when software must be maintained, secured, audited, and owned by teams over time.

Steered agentic development addresses these limitations by keeping humans accountable for decisions, constraints, and approvals while allowing agents to execute within clearly defined boundaries and provide evidence of their work. HVE builds on this model by combining structured workflows, reusable primitives, governance, and continuous automation to support reliable enterprise delivery at scale.

Before examining how agentic development changes software delivery, Chapter 2 clarifies what is meant by AI agents and agentic AI, and introduces the human-agent collaboration model required for their effective use.

1. GitHub: "Research: Quantifying GitHub Copilot's impact on developer productivity and happiness." https://github.blog/news-insights/research/research-quantifying-github-copilots-impact-on-developer-productivity-and-happiness/
2. GitHub: "Research: Quantifying GitHub Copilot's impact in the enterprise with Accenture." https://github.blog/news-insights/research/research-quantifying-github-copilots-impact-in-the-enterprise-with-accenture/
3. Faros AI: "The AI Productivity Paradox: What Our Data Shows About AI in Software Engineering." https://www.faros.ai/blog/ai-software-engineering
4. CodeRabbit: "State of AI vs Human Code Generation Report." https://www.coderabbit.ai/blog/state-of-ai-vs-human-code-generation-report
5. Aikido Security: "2026 State of AI in Security & Development." https://www.aikido.dev/reports/2026-state-of-ai-in-security-development
6. Andrej Karpathy: Original "vibe coding" post on X, February 2025. https://x.com/karpathy/status/1886192184808149383
7. MIT Sloan Management Review and Boston Consulting Group: "The Emerging Agentic Enterprise: How Leaders Must Navigate a New Age of AI." https://sloanreview.mit.edu/projects/the-emerging-agentic-enterprise-how-leaders-must-navigate-a-new-age-of-ai/
8. Microsoft: "The 2025 Annual Work Trend Index: The Frontier Firm is born." https://blogs.microsoft.com/blog/2025/04/23/the-2025-annual-work-trend-index-the-frontier-firm-is-born/
9. Microsoft ISE Developer Blog: "Separating Deterministic Extraction from AI Inference in Industrial Summarization." https://devblogs.microsoft.com/ise/separating-deterministic-extraction-from-ai-inference/
10. TelcoDR: "Ep 122 – Microsoft's hypervelocity engineering for hypervelocity telcos (Robin Cole)." https://telcodr.com/insights/ep-122-hypervelocity-engineering-telcos/

1. Simon Willison: "Not all AI-assisted programming is vibe coding." https://simonwillison.net/2025/Mar/19/vibe-coding/
2. Collins Dictionary: Word of the Year 2025: Vibe Coding. https://www.collinsdictionary.com/woty
3. GitHub Spark: AI-powered application development. https://github.com/features/spark
4. GitHub Docs: Building and deploying AI-powered apps with GitHub Spark. https://docs.github.com/en/copilot/tutorials/spark/build-apps-with-spark
5. Microsoft: HVE Accelerators Hub. https://learn.microsoft.com/en-us/industry/playbook/
6. Microsoft: "How Frontier Firms are rebuilding the operating model for the age of AI." https://blogs.microsoft.com/blog/2026/05/05/how-frontier-firms-are-rebuilding-the-operating-model-for-the-age-of-ai/
7. Replit Agent: AI application development environment. https://replit.com/ai
8. Lovable: Natural-language full-stack application builder. https://lovable.dev/
9. Bolt: AI-powered application builder. https://bolt.new/
10. Vercel v0: Generative UI and application development. https://v0.dev/
11. Cursor: Agentic development environment. https://www.cursor.com/
12. GitHub Copilot: AI coding assistant and coding agents. https://github.com/features/copilot