Artificial IntelligenceTech

When AI Codes: Assistants, Workflows, and Adoption in Software Engineering in 2025

Léo GaudezLéo Gaudez•2025-11-03•22 min read
When AI Codes: Assistants, Workflows, and Adoption in Software Engineering in 2025

When AI Codes: Assistants, Workflows, and Adoption in Software Engineering in 2025

Find the associated podcast: 🎧 Listen Now (French only) 🎧

Imagine a world where over 80% of software development professionals use artificial intelligence daily.
Welcome to October 2025!

The latest data from the Stack Overflow Developer Survey 2025 shows that the vast majority of developers have already adopted AI tools or plan to do so in the near future, while about one in two use them daily to write, review, or document code. At the same time, ShiftMag's analysis of these results highlights a paradox: nearly half of respondents report not fully trusting AI's answers, even as they use it massively.

Above all, we must distinguish between two realities:

  • On one hand, "classic" code completion (Copilot, IDE suggestions, etc.), which is now almost ubiquitous.
  • On the other, AI agents capable of orchestrating complex workflows (planning, multi-step execution, repo modifications, etc.), which are still in the minority: according to the "AI Agents" section of the survey, a minority of developers use them regularly, and more than half have not yet integrated them into their daily practice.

On the impact side, GitHub's initial studies on Copilot measured spectacular gains: developers complete certain tasks up to 55% faster when using Copilot, while also reporting improved satisfaction and reduced cognitive load. But in 2025, the revolution is no longer measured just in lines of code produced or typing speed. It's playing out in the shift from exploratory "vibe coding"—where developers just "throw prompts at the AI"—to rigorous, traceable, and reproducible methodologies.

In this article, we will:

  • map out the ecosystem of tools enabling this change;
  • compare two major players: Cursor and Claude Code;
  • break down the new workflows (Spec-Driven Development, BMAD, etc.);
  • and understand how these practices are transforming the human developer into an architect and orchestrator of autonomous agents.

1. The 2025 Ecosystem: From Foundation Models to Dev Tools

1.1. Foundation Models: The "Invisible" Layer Powering the Tools

At the top of the stack, we find the foundation model providers that power most of the tools developers use:

  • OpenAI with GPT-5 (August 2025) and its specialized code variants, integrated into many products (Copilot, plugins, IDEs, etc.).
  • Anthropic, with the Opus and Sonnet series (4.5 in September 2025), which stand out for their strong focus on reasoning, autonomy, and safety, and which are at the heart of Claude Code.
  • Google DeepMind with Gemini 2.5 Pro (June 2025), often highlighted for its massive context windows (up to 1M tokens in some use cases) and its integration into Gemini Code Assist and Gemini CLI.
  • xAI, with Grok 3 (February 2025) and more recently Grok 4, which bets on an aggressive price/performance ratio and near-real-time access to certain public sources.

Facing these proprietary offerings, the open-source ecosystem is advancing rapidly:

  • Llama 3 / 3.1 from Meta, which have become de facto standards for many self-hosted deployments.
  • DeepSeek V3 and V3.1, very powerful Mixture-of-Experts models, available via API and, in some variants, with reusable weights and an open-source-oriented license.

These models are rarely handled "raw" by developers. They come to life through tools and workflows.

1.2. Four Major Families of Tools for Developers

For development teams, 2025 is organized around four categories of AI tools:

  1. Conversational Assistants & Code Completion

    • General-purpose chatbots (ChatGPT, Claude, Gemini, Grok, etc.) used via the browser.
    • Completion tools like GitHub Copilot, Cline, TabNine, or Cursor's "Tab" models.
    • This is the foundation of the first wave: completing lines of code, generating snippets, explaining functions.

  2. AI-Native IDEs

    • Cursor (An AI-native IDE based on a fork of VS Code, highly focused on agentic orchestration, context management, and UX).
    • Windsurf, the agentic IDE from Cognition (creator of Devin), now heavily focused on enterprise and large monorepos—and now owned by Cognition after a particularly turbulent M&A sequence.
    • Kiro, the agentic IDE from AWS, designed from the ground up with a Spec-Driven Development process.
    • Junie, the AI agent launched in 2025 by JetBrains, is gradually arriving (October 2025) in the JetBrains suite: it is already available in IntelliJ IDEA Ultimate, PyCharm Pro, WebStorm, and GoLand.

    All these IDEs share one idea: AI is no longer a plugin; it's the central architecture of the tool. They manage the indexing of entire projects, orchestrate multiple agents, and offer Plan → Execute modes to guide development.

  3. Intelligent CLIs (Agents driven from the terminal)

    • Claude Code, increasingly used as an agentic CLI (and now also via a dedicated web interface).
    • Aider, an open-source AI pair programming project in the command line.
    • OpenCode, an open-source multi-model CLI built for the terminal.
    • Gemini CLI, Google's open-source agent that brings Gemini to the terminal, with a ReAct loop and support for the Model Context Protocol.
    • GitHub Copilot CLI, now in public preview, which brings Copilot's "coding agent" directly into the terminal and explicitly positions itself as a competitor to Claude Code, Aider, Codex CLI, or Gemini CLI.

    These tools share a promise: "tell the terminal what you want" in natural language rather than remembering complex commands or scripts, all while autonomously driving the entire development cycle.

  4. End-to-End AI Platforms

    • Replit, Bolt, Lovable, or certain no-code/low-code workflows.
    • The ambition: take a simple prompt and produce a functional application / prototype (deployed or not).

  5. Asynchronous Agents

    • To these four building blocks, a fifth movement is added, which we won't detail here: asynchronous agents like Cursor's background agents, Jules from Google, or Devin, capable of working "in the background" on branches or PRs.

Note 1: We will also not detail the specialized "downstream" services (code review, QA, security review...) like Qodo, CodeRabbit, or Bugbot, even though they are part of the same trend: industrializing and making the contribution of AI reliable at all stages of the software lifecycle. Note 2: This mapping of AI tools for developers is not exhaustive; it highlights the most representative and widely used solutions in 2025.

2. Cursor vs. Claude Code: Two Philosophies, One Goal

The Cursor vs. Claude Code duel illustrates two distinct approaches to AI-assisted coding:

  • Cursor: A native and fluid IDE experience, where AI integrates into the editor you already know.
  • Claude Code: An autonomous and versatile agent, designed first for the terminal and later extended to the web.

2.1. Cursor: IDE-first

Cursor is a fork of VS Code, designed as an AI-native IDE:

  • It automatically indexes your codebase (code, docs, configs) and allows you to target files, folders, or even external documentation in requests.
  • It is multi-model: you can use GPT-5, Claude, Gemini, Grok, or the in-house Composer model, introduced with Cursor 2.0 to optimize agent speed.
  • Since October 2025, Cursor has introduced a multi-agent interface (up to eight agents in parallel in 2.0) and a Plan mode that allows configuring implementation plans and comparing several variants before merging the diffs.

In terms of adoption, Cursor shows skyrocketing growth:

  • More than 1 million developers use it, including several hundred thousand paying subscribers.
  • The company has surpassed $100M in ARR in record time and is aiming for $200M this year, with valuations now in the billions.
  • Numerous field reports (articles, newsletters, internal studies) indicate significant productivity gains, especially for teams that shift "their entire workflow" into Cursor (coding, refactoring, review, docs, etc.).

Configuration: .mdc Files and Hooks

Cursor's great strength is its system of contextual rules:

  • It relies on .mdc (Markdown Cursor) files that contain:
    • instructions for the AI (style, conventions, architectural constraints, best practices, etc.);
    • metadata that defines where and when to apply these rules (by directory, task type...).
  • Some rules can be global and always active, while others only trigger in a specific context (e.g., only for test files in a module) or can be passed explicitly in the prompt.
  • Hooks allow triggering specific behaviors (e.g., systematically running tests or linters after each implementation plan).

Result: When teams invest in these rules, context engineering becomes a real lever for quality and consistency.

On the pricing side, Cursor offers:

  • a Pro plan around $20/month for individuals, with its pool of credits or almost unlimited use with its auto mode (Cursor uses the model best suited for the prompt);
  • Team / Enterprise plans around $40/user/month with SSO, governance, centralized billing, etc. Complementary products like Bugbot (PR review and error detection) or background agents are billed separately, typically ~$40/user/month.

2.2. Claude Code: agent-first, terminal-first, and sub-agents

Claude Code is Anthropic's "coding agent" offering. Historically centered on the CLI and the terminal, it is also accessible via a dedicated web interface.

Its philosophy:

  • Agent-first: Claude Code behaves like an autonomous collaborator capable of, among other things:
    • navigating entire repos;
    • executing commands;
    • running tests;
    • proposing structured refactorings.
  • Terminal-first: The primary use remains the terminal, even if a VS Code extension allows integrating Claude Code into IDEs.
  • Sub-agents: This is one of the major differentiators:
    • a main agent delegates to specialized agents (reviewer, test-runner, debugger, refacto, etc.);
    • each sub-agent has its own system prompt, tools, and an adapted context window.

In practice, this allows for workflows like:

  • "Prepare a detailed implementation plan based on this spec."
  • "Have this plan reviewed by the architect agent."
  • "Break it down into tasks for the dev agent."
  • "Run the tests and have the diffs reviewed by the reviewer agent."

Hierarchical Configuration and Governance

On the configuration side, Claude Code adopts a more hierarchical approach than Cursor:

  • global settings (organization, user, workspace...);
  • overrides per project then per module;
  • configuration of sub-agents (roles, rules, allowed tools, etc.).

This hierarchy pairs well with the governance requirements of large enterprises (regulated sectors, strong constraints on security and traceability):

  • fine-grained permissions management;
  • detailed action logs;
  • integration with access control and compliance tools.

On the pricing side (October 2025), Claude Code is currently accessible via Claude Pro and Claude Max subscriptions:

  • Pro: around $20/month, with a generous quota on standard usage and access to Claude Code within the limit of a 5-hour rolling usage window (roughly, about forty prompts on Claude or ten to a few dozen very heavy Claude Code requests).
  • Max: around $100/month, for intensive use and larger usage windows.

Usage quotas reset every 5 hours. With heavy use, it's possible to hit the limit fairly quickly and have to wait for the next window.

2.3. Interoperability, Emerging Standards, and Total Cost

Switching from Cursor to Claude Code (or vice versa) is not trivial. Teams want to:

  • reuse their prompts, rules, hooks, specs;
  • avoid maintaining two completely different configurations.

To address this, several initiatives are emerging:

  • the Ruler (Intellectronica) library, which proposes a unified format for rules and prompts, allowing them to be reused across different tools;
  • approaches like AIDD (AI-Driven Development) or the AI Dev Kit, which try to standardize how agents interact with context and specifications.

This is all still experimental: standards like AGENTS.md cover simple cases well, but as soon as you use very specific features (Claude Code sub-agents, Cursor .mdc files, etc.), you still need to adapt manually.

Finally, the total cost plays a strategic role:

  • most of these tools start around $20/month per user for individual use,
  • but you must add:
    • API surcharges (frontier models, or intensive agentic use);
    • add-ons (Bugbot, quality tools, etc.);
    • and potentially infrastructure costs if self-hosting open-source models.

Many teams therefore end up, due to budget and operational constraints, standardizing on one primary tool (e.g., Cursor or Windsurf) while keeping a second tool (Claude Code, Gemini) for specific use cases.

3. New Workflows: From Vibe Coding to Spec-Driven Development and BMAD

"Classic" agile methodologies (PRDs, epics, user stories, acceptance criteria...) do not disappear with AI. On the contrary: AI works better when framed by clear and structured artifacts.

3.1. Vibe Coding vs. Structured Development

We talk about "vibe coding" when a developer:

  • gives the AI fairly broad objectives ("make me an analytics dashboard," "rewrite this service to be cleaner," etc.);
  • lets the agent explore, generate code, execute commands, and iterate;
  • focuses more on the observable result (tests passing, app running) than on a deep understanding of the code.

This practice, popularized by some figures in the community and widely studied in the tech media, has advantages:

  • rapid prototyping;
  • reduced barrier to entry for non-experts;
  • ability to explore several paths in parallel.

But studies and experience reports also point to risks:

  • fragile architecture, hidden technical debt, poor scalability;
  • subtle bugs and security issues that are difficult to detect;
  • difficulty in maintaining the code when the team changes.

Articles like "Senior developers are all in on vibe coding, but junior staff lack the experience to spot critical flaws" (ITPro) or recent analyses on the near-systematic use of AI in some teams show that experienced developers get more out of vibe coding, but juniors can be trapped by code that "works" but violates essential constraints (performance, security, business rules...).

Hence the rise of methods like Spec-Driven Development (SDD) or BMAD, which seek to channel the power of agents rather than be overwhelmed by it.

3.2. Spec-Driven Development (SDD) and GitHub Spec Kit

Spec-Driven Development starts from a simple idea:

Before asking the AI to write code, let's write a structured specification that will become the source of truth—for humans and AI agents.

GitHub has materialized this approach with GitHub Spec Kit, an open-source toolkit designed to work with Copilot, Claude Code, Cursor, Kiro, etc.

The "canonical" flow is broken down into four phases:

  1. Specify

    • The intent is captured in a spec document:
      • business needs, objectives;
      • technical constraints;
      • acceptance criteria.
    • With Spec Kit, you can use commands like /specify in your agent or the specify command-line tool to turn a brief into a structured spec (often in Markdown format).

  2. Plan

    • Based on the spec and the context (stack, architecture, non-functional constraints...), the AI generates an implementation plan:
      • successive steps;
      • dependencies;
      • identified risks.
    • The developer iterates with the AI until the plan is satisfactory. The idea is to lock in an execution path before writing a single line of code.

  3. Tasks

    • The plan is then "atomized" into actionable and testable tasks:
      • ideally the size of a coherent PR;
      • referencing the spec and the plan;
      • containing all the necessary context to be implemented by an agent (or a junior developer).
    • Some implementations (Spec Kit, Kiro, etc.) directly produce task files (YAML/Markdown) that agents can consume.

  4. Implement

    • The AI executes the tasks: code generation, tests, docs.
    • The human remains in the loop:
      • reviewing diffs;
      • validating or adjusting the plan;
      • making architectural decisions.

This SDD flow might seem heavy for small changes. In practice, teams adapt:

  • for small, isolated changes like wording updates or design improvements, they often stick to a more "vibe + review" cycle;
  • for a major feature or deep refactors, SDD brings clarity and traceability.

3.3. BMAD: Orchestrating Specialized Agents with Story Files

The other structured approach in vogue is the BMAD Method (often available as an open-source framework).

The idea: formalize a multi-agent team representing different human roles in the development cycle:

  • Analyst
  • Product Manager
  • Architect
  • Developer
  • Scrum Master
  • etc.

BMAD offers a 5-level system (0-4) that adapts the depth of planning and documentation according to complexity.

Unlike a rigid method, BMAD automatically "doses" the necessary level of planning, documentation, and orchestration.

A 4-Phase Methodology

  1. Analysis (optional): brainstorming, research, product briefs
  2. Planning (required): generation of PRD/tech-spec/GDD adapted to the level
  3. Solutioning: architectural and design decisions
  4. Implementation (iterative): story-centric development with "just-in-time" context

12 Orchestrated Specialized Agents

Beyond the classic roles (PM, Analyst, Architect, Developer, Test Architect, UX Designer), BMAD integrates:

  • A BMad Master who orchestrates the entire process
  • Specialized agents for game dev (Game Designer, Game Developer, Game Architect)
  • An agent dedicated to documentation

Each agent only intervenes when necessary according to the complexity level.

Intelligent Context Management

BMAD solves the problem of context overload via:

  • Document sharding: for Level 3-4 projects, workflows only load relevant sections (90%+ token reduction)
  • Just-in-time context: each agent receives only what it needs for its task
  • Story-centric implementation: in Phase 4, work is done story by story with targeted context

Important Distinction: CORE vs. Method

  • BMAD-CORE: the underlying framework (agent orchestration, workflows, modular architecture)
  • BMM (BMad Method Module): the software development module with its 12 agents and 34 workflows
  • BMB (BMad Builder): to create your own custom agents/workflows
  • CIS (Creative Intelligence): creative facilitation workflows

In summary:

  • Spec Kit / SDD: A structured pipeline (spec → plan → tasks → implementation) that allows for a quick start and keeps the human in command.
  • BMAD: Multi-agent orchestration with formalized roles (analyst, architect, dev...) and Story Files that carry all useful context (objectives, constraints, architecture rules, acceptance criteria).

Advantages and Constraints:

Spec KitBMAD
SetupQuick to set upLonger before delegating
FlexibilityLess constrainingVery rigid execution plan
TraceabilityGood, human-drivenExcellent, clear handoffs
IterationsMay require back-and-forth
Less back-and-forth when requirements change

Note: Each team can adapt these methods based on complexity—pre-configuring steps, re-dividing them, or adding new ones. It's even possible to combine approaches depending on the project phase. These methods can be used in most tools, and certain phases can be executed in different tools (e.g., Gemini Gems then Claude Code).

Cost Optimization: Both methods allow for using different models depending on the phase:

  • "Heavy reasoning" models (slower, more expensive) for analysis and architectural decisions
  • Faster, more economical models for highly targeted implementation tasks

The common goal: Eliminate context loss or context overload, and better direct the AI to reduce errors.

4. Adoption, Impact, and the New Role of the Developer

4.1. Massive Adoption, Mixed Trust

As mentioned in the introduction, the 2025 numbers are telling:

  • > 80% of developers report using AI tools or planning to do so in their workflows;
  • about one in two use them every day;
  • but nearly half indicate they do not trust them.

On the agent side, data from the "AI Agents" section of the same survey (StackOverflow) show that:

  • a significant minority (around one-third) already use agents at least once a month;
  • more than half remain limited to simpler tools (completion, occasional chat) or do not use AI at all.

This gap clearly illustrates the state of the market: the tools are here, powerful, sometimes impressive—but organizations do not all yet have the culture, the guardrails, and the workflows to derive systematic benefit from them.

4.2. Cursor vs. Claude Code in Enterprises

We are generally observing a polarization of usage:

  • Startups, indie hackers, small product teams

    • strong adoption of Cursor and sometimes Windsurf, for their speed, UX, and deep integration into the daily development flow;
    • common use of vibe coding, often balanced by tools like CodeRabbit and human code reviews.

  • Large enterprises, regulated sectors (finance, health, cybersecurity, public sector...)

    • marked interest in Claude Code (execution logs, governance, permissions management, integration with locked-down environments, native VS Code extension);
    • Gemini CLI for Google Cloud/Workspace developers seeking native integration with the Google ecosystem.

  • Emerging Structured Approaches

    • Kiro (AWS, July 2025): pioneer of spec-driven development with requirements.md/design.md/tasks.md based on EARS, aiming to replace "vibe coding" with formal planning;
    • JetBrains Junie: agentic agent in JetBrains IDEs (IntelliJ, PyCharm) with 60.8% on SWEBench, focusing on transparency and developer control.

In practice, the line isn't clear-cut:

  • Cursor is strengthening its guardrails (privacy mode, fine-grained control over data sent to models, security hooks, integrated Code review, Bugbot for automated code review);
  • Claude Code is improving its integration into IDEs (VS Code extension, "Code" tab in the web interface, better UX for managing long sessions);
  • other IDEs like Kiro are pushing Spec-First approaches, very close to SDD workflows.

4.3. The New Role of the Developer

In this context, the developer does not disappear—but their role changes profoundly.

Rather than producing code line by line, they become:

  • an orchestrator of software intelligence:

    • They understand business needs and structure specs;
    • Choose and adapt to tools (Cursor, Claude Code, Kiro, Gemini CLI...);
    • Configure rules, prompts, hooks, CI/CD;
    • Supervise plans and executions.

  • responsible for product/technical alignment:

    • they ensure that code generated by agents respects business, security, and performance constraints;
    • they arbitrate between rapid experiments (vibe coding) and industrialization (SDD, BMAD).

  • a guardian of quality:

    • they remain responsible for the code, reviews, tests, and maintainability;
    • they don't just "patch" generated code without worrying about the global architecture.

Performance metrics are also evolving:

  • we are moving away from the volume of code produced as a primary indicator;
  • we are refocusing on:
    • deployment frequency;
    • lead time from commit to production;
    • change failure rate in production;
    • mean time to restore (MTTR) in case of an incident;
  • and, above all, real product/business impact.

Works like those in the book Accelerate or DORA metrics remain highly relevant in this world where AI "codes" for devs: they remind us that it's not the quantity of code or the number of meetings that defines a team's performance, but its ability to ship frequently, reliably, and with rapid feedback.

5. Conclusion: Coding with Discernment

The year 2025 marks the end of the "gadget phase" and the entry into an era of AI-structured software development.

  • Tools like Cursor, Claude Code, Windsurf, or Kiro are no longer simple assistants: they are complete environments that orchestrate agents, manage context, and directly modify code.
  • Methodologies like Spec-Driven Development (with GitHub Spec Kit) or the BMAD Method provide a clear, traceable, and collaborative framework for this human-AI collaboration.
  • The companies that succeed are not those that "automate everything," but those that know how to design robust workflows, aligned with their constraints and product strategy.

The developer becomes an orchestrator:

  • they design the workflows,
  • validate the plans,
  • keep control over structural decisions.

The key remains profoundly human: rigor, curiosity, product sense, and the ability to build good workflows.
The future of code will be played out in this alliance between creativity and control, automation and discernment.

You can also follow related content on LinkedIn, or contact me directly via [email protected] to discuss Tech or Product topics.

By Léo Gaudez Let's explore the future of AI-driven development together.

🔗 Associated Podcast (French)

🎧 Episode: When AI Codes: Assistants, Workflows, and Adoption in Software Engineering in 2025

📚 Resources

Primary Sources for This Episode

Additional Resources (Ecosystem & Workflows)

(Non-exhaustive list — for continuous updates, refer to the official tool changelogs and vendor blogs.)

← Back to resources
When AI Codes: Assistants, Workflows, and Adoption in Software Engineering in 2025 | Gaudez Tech Lab