BridgeMind Platform: Conceptual Foundations, Technology Stack, and Inspirations for Agentic Coding Platforms

Executive Summary

BridgeMind is a builder-focused platform for AI-assisted and agentic software development built around the concepts of "vibe coding" (natural-language-driven coding) and "agentic coding" (multi-agent AI teammates with structured workflows). BridgeMind integrates four main products—BridgeSpace, BridgeMCP, BridgeCode, and BridgeVoice—into a single workflow that turns natural-language intent into coordinated agent execution over real codebases.[^1][^2][^3][^4]

For a new platform, BridgeMind is useful as a reference for: (1) its clear conceptual framing of development paradigms (AI coding, vibe coding, agentic coding); (2) the way it treats AI agents as first-class teammates coordinated via explicit project/task models; and (3) its concrete engineering choices for an Agentic Development Environment (ADE) desktop app, Model Context Protocol (MCP) server, and multi-agent orchestration patterns.[^2][^5][^6][^4]

Conceptual Foundations

AI Coding as Umbrella Paradigm

BridgeMind positions "AI coding" as the umbrella for multiple development styles where AI accelerates but does not replace human decision-making. In this framing, builders own product direction, architecture, and final approval, while AI tools provide scaffolding, code generation, explanation, and debugging support.[^5]

AI coding is described as shortening the distance between an idea and a working implementation by using AI to scaffold features, generate code, review changes, and accelerate debugging rather than writing every line manually. This aligns with broader literature on LLM-based coding assistants that emphasizes human-in-the-loop workflows and the shift from manual syntax to higher-level intent specification.[^7][^8][^5]

Vibe Coding: Natural-Language Centric Development

Vibe coding is defined as building software by describing what is wanted in natural language and letting AI agents write the code, with the human focusing on "vision" while AI handles syntax. The core loop replaces traditional code–compile–debug with describe → generate → review → iterate, emphasizing fast feedback cycles.[^3]

BridgeMind contrasts vibe coding with traditional development across several dimensions: primary input (natural language vs. manual coding), builder role (architect/reviewer vs. typist/debugger), iteration speed (minutes–hours vs. hours–days), barrier to entry (communication skills vs. years of practice), and context management (AI-maintained project context vs. purely human mental models and docs). This mirrors external discussions of natural-language programming and LLM-assisted prototyping where natural language becomes a first-class interface for specifying behavior.[^9][^10][^3]

Agentic Coding: AI Agents as Teammates

"Agentic coding" is defined as a methodology where AI agents operate as autonomous teammates that claim tasks, write code, and submit work for human review. Rather than a reactive assistant, each agent has a role (Architect, Frontend, Backend, QA), shared access to task boards and accumulated "Task Knowledge", and operates within a structured task lifecycle (todo → in-progress → in-review → complete) with human approval gates.[^6][^4]

This approach aligns closely with emerging literature on agentic programming and multi-agent coding, which emphasizes autonomy (agents plan and act), context (shared state and memory), and control (guardrails and human checkpoints). BridgeMind explicitly positions itself as an agentic organization where AI agents have defined roles and can investigate codebases, apply changes, and hand work back for review.[^11][^12][^13][^14][^15][^6]

Relationship Between Vibe, Agentic, and AI Coding

BridgeMind treats AI coding as the broad category, with vibe coding and agentic coding as overlapping sub-paradigms emphasizing different aspects of the workflow. Vibe coding optimizes for flow-state interaction, rapid prototyping, and conversational loops, while agentic coding emphasizes structured multi-agent execution, task lifecycle management, and team-like coordination.[^2][^5][^6][^3]

This mirrors external analyses that distinguish conversational, human-in-the-loop modes (vibe-style) from goal-directed, autonomous agent modes (agentic coding), while arguing that practical systems should blend both.[^16][^12][^17]

Product Architecture and Components

High-Level Product Stack

BridgeMind exposes four primary products as parts of a single workflow:[^2]

BridgeSpace – Agentic Development Environment (ADE) combining multi-pane terminals, a Kanban task board, and agent orchestration in a single native desktop app.[^1][^2]
BridgeMCP – Model Context Protocol (MCP) server that connects AI editors (Cursor, Claude Code, etc.) to shared projects, tasks, agents, and tools, acting as the central context and orchestration layer.[^4][^2]
BridgeCode – Agent-first desktop IDE / CLI that turns natural-language task descriptions into multi-step code changes, with plan-based execution and native Claude integration (in public materials, this is positioned as a coming or evolving product).[^5][^1][^2]
BridgeVoice – Voice interface that uses Whisper locally or cloud speech-to-text to translate spoken intent into agent prompts, enabling hands-free coding in 99+ languages.[^3][^1][^2]

These products are sold in Basic and Pro plans, where Basic provides BridgeSpace and swarms, while Pro unlocks the full stack (BridgeMCP, BridgeVoice, BridgeCode).[^1]

BridgeSpace: Agentic Development Environment (ADE)

BridgeSpace is a native desktop app (Tauri v2 + React 19) that unifies the terminal, task board, and AI agent orchestration into one window. Key capabilities include:[^1]

Workspace grids: Preconfigured panes (2-side, 2×2, 3×4, 4×4) with up to 16 terminals, all sessions created in parallel for zero-wait startup.[^1]
AI agent auto-launch: During workspace creation, users select agent configurations; the app waits for shells to initialize then starts each agent concurrently, providing immediate multi-agent presence.[^1]
Integrated task board: A Kanban board synced with the BridgeMind API where each task can be "Run" to spawn a terminal with the associated agent and full task context injected automatically.[^1]
Built-in editor panes: Quick file open and in-place editing alongside terminals using lightweight editor panes, reducing context switching with external IDEs.[^1]
Warp-style command blocks: Shell output is grouped into collapsible blocks via OSC 133 integration, improving observability and history navigation even with verbose agent logs.[^1]
Native performance stack: Tauri v2 for OS integration, node-pty for real shell processes, xterm.js with WebGL for GPU-accelerated terminal rendering, emphasizing low memory usage compared to Electron and preserving user shell configs (.zshrc, .bashrc).[^1]

BridgeSpace also includes BridgeSwarm, a multi-agent orchestration feature where users "give a goal, get a product" through coordinated agent teams. BridgeSwarm supports role assignment (builder, reviewer, scout, coordinator), an inter-agent mailbox system, live activity feed per agent, and scaling from 2 to 16 agents.[^1]

BridgeMCP: MCP Server and Tool Layer

BridgeMCP is the MCP server that exposes project, task, and agent management as tools usable from any MCP-compatible editor. The documentation describes a standard four-step onboarding: obtaining an API key, configuring the editor MCP JSON, creating a project via the agent, and then shipping with agents via tasks.[^4][^2]

The server exposes tools grouped into three categories:[^4]

Projects: list_projects, create_project.
Tasks: list_tasks, get_task, create_task, update_task.
Agents: list_agents, get_agent, create_agent, update_agent.

Each tool is designed to be called by the AI agent itself rather than manually by the user, using natural-language instructions (e.g., "Create a project for the auth refactor" → create_project, "Create a task to fix the login bug" → create_task).[^4]

BridgeMCP encodes the task lifecycle and Task Knowledge model: tasks move through todo, in-progress, in-review, complete, and as agents work they write file paths, error traces, and findings into Task Knowledge fields; humans change state to complete or bounce back to todo with revised instructions.[^6][^4]

BridgeCode: Agent-First IDE / CLI

Public materials describe BridgeCode as an "agent-first desktop IDE" with natural-language feature work, agent-assisted implementation, and plan-based execution inside a multi-panel workspace. While full documentation is limited, it is positioned as the environment where a builder can assign a task and the agent investigates, implements, tests, and submits for review autonomously.[^5][^6][^1]

BridgeCode aligns conceptually with agentic coding literature describing coding agents that plan, execute, test, and iterate on tasks with a high degree of autonomy while maintaining human review checkpoints.[^12][^13][^18][^14]

BridgeVoice: Voice-to-Agent Interface

BridgeVoice provides a voice-controlled coding interface using Whisper locally or cloud-based speech recognition, supporting 99+ languages for hands-free development. It is designed to integrate with BridgeSpace and BridgeMCP so voice prompts can be converted into structured agent tasks, aligning with the theme of "coding at the speed of thought" via voice, as described in BridgeMind’s live-build content.[^19][^20][^3][^2][^1]

Interaction and Workflow Design

Vibe Coding Workflow

The vibe coding guide describes a four-step loop:[^3]

Describe intent – Builder expresses goals, constraints, and success criteria in natural language.
AI agents generate code – AI interprets intent and writes implementation (file structure, business logic, error handling, tests).
Review and iterate – The builder reviews output, requests changes, and iterates.
Ship with confidence – Human approval is required before deployment; vibe coding is explicitly human-in-the-loop.

BridgeMind treats vibe coding as a methodology rather than just "using ChatGPT to write code" by including agentic workflows, project context management, multi-agent coordination, and structured task lifecycles as core elements.[^3]

Agentic Coding Workflow

The agentic coding guide shows a worked example of building a user dashboard via an agentic workflow. Key patterns include:[^6]

Project creation by Architect agent, which breaks features into tasks (API, DB, frontend, tests).[^6]
Parallel task claiming by specialized agents (Backend, Frontend), each moving tasks to in-progress and writing to Task Knowledge.[^6]
Review handoff where agents move tasks to in-review for human inspection and approval or rework.[^6]
Strict lifecycle enforcement so no task reaches complete without a human decision.[^4][^6]

These workflows reflect patterns recommended in external guidance on agentic coding and multi-agent orchestration: explicit role prompts, shared context, phase-based coordination, and human checkpoints at decision boundaries.[^21][^22][^23][^24]

Task Management and Shared Memory

BridgeMind’s task management system is central to both vibe and agentic coding. Tasks carry:[^4][^6]

Natural-language instructions.
Status (todo, in-progress, in-review, complete).
Task Knowledge as an append-only log of findings, file paths, error traces, and reasoning.

Agents use list_tasks and get_task to discover work, update_task to claim and submit work, and humans use the same tools (via editors or dashboards) to control state transitions. This design echoes emerging practices around AI-context files (e.g., AGENTS.md) and structured context engineering for coding agents.[^25][^26][^4]

Multi-Agent Swarm Orchestration

BridgeSwarm provides an orchestration layer where multiple agents with different roles (builder, reviewer, scout, coordinator) collaborate through a mailbox and are visualized in BridgeSpace. The system offers a live activity feed and supports up to 16 agents, mapping well to multi-agent orchestration patterns described in industry analyses and architecture guides.[^17][^14][^27][^24][^1]

BridgeSwarm’s design is aligned with best practices identified in external case studies: coordinator-first routing, clear agent scopes, phase-based workflows (planning, implementation, testing, review), process isolation per agent, and trace propagation for observability.[^22][^23][^27]

Engineering and Technology Choices

Desktop Runtime and Performance

BridgeSpace is implemented on Tauri v2 with React 19, using node-pty and xterm.js (WebGL) for terminal rendering. This yields:[^1]

Native OS integration with significantly lower memory usage than Electron-based apps.[^1]
Preservation of existing shell configuration (no separate sandbox) for a more natural developer experience.[^1]
GPU-accelerated terminal rendering capable of handling multiple agent sessions concurrently.[^1]

The choice of Tauri and WebGL aligns with a broader trend towards lightweight, high-performance desktop shells that can host intensive AI-driven interaction while minimizing overhead.[^27]

MCP Integration and Tool Design

BridgeMCP adheres to the Model Context Protocol pattern, exposing a JSON-configured server URL and bearer token header for authentication from editors like Cursor and Claude Code. The configuration is simple (mcpServers entry in ~/.cursor/mcp.json) and is intended to keep all routing and orchestration logic inside the MCP server rather than within individual editors.[^4]

The tool design encourages agents to use semantically simple verbs (list_, create_, update_) and to operate on opaque IDs (projectId, taskId, agentId), which is consistent with good API design and with survey recommendations for agentic toolchains that emphasize clean separation of planning, state, and execution.[^15][^24][^12]

Observability and Log Structure

Command-block grouping via OSC 133 and the use of workspace grids provide rich observability over agent behavior and shell commands. This supports debugging, auditing, and trust in agentic execution, which are identified as critical in research on agentic coding security and production readiness.[^28][^23][^1]

Human-in-the-Loop Safeguards

Across the docs and guides, BridgeMind consistently emphasizes human ownership of architecture, product decisions, and final approval. Tasks cannot reach complete without human review, and BridgeMCP’s lifecycle makes this explicit. This matches safety recommendations in surveys and security studies that urge human checkpoints and layered verification for agentic coding systems.[^29][^13][^28][^12][^2][^5][^3][^6][^4]

Academic and Industry Context

Agentic Programming and Multi-Agent Systems

Recent surveys on AI agentic programming describe architectures where LLM-based agents autonomously plan, execute, and interact with tools such as compilers, debuggers, and version control systems, iterating based on feedback. These works identify key properties: autonomy, interactivity with tools, iterative refinement, and goal-oriented behavior—properties that BridgeMind’s agentic coding stack intentionally exposes via Agents, Tasks, and BridgeMCP tools.[^12][^15][^6][^4]

Other studies on agentic coding emphasize how multi-agent systems move beyond single-suggestion assistants toward autonomous agents that handle planning, testing, and refactoring. Empirical results show that agent-generated PRs are generally acceptable but benefit from human review, validating BridgeMind’s insistence on human-in-the-loop lifecycle gates.[^30][^11][^29]

Orchestration Patterns and Context Engineering

Industry guidance on AI agent orchestration emphasizes starting with low complexity (single agent + tools), then moving to multi-agent orchestration when needed, with clear patterns such as sequential, concurrent, group chat, and handoff orchestration. BridgeSwarm and BridgeMCP embody these ideas through coordinator roles, task boards, mailbox communication, and phase-based workflows.[^24][^6][^4][^1]

Recent work on context engineering (e.g., AGENTS.md adoption studies) highlights the importance of external, version-controlled context artifacts that AI agents can rely on for project norms, structure, and policies. BridgeMind’s Task Knowledge and agent prompts play a similar role as structured, external context that is accessible to agents across sessions.[^25][^6][^4]

Security and Risk Considerations

Security research on agentic AI coding editors has revealed the risk of prompt-injection attacks where external artifacts can hijack agents and cause malicious command execution, especially in high-privilege environments with terminal access. BridgeMind’s command-block visibility, shared task logs, and explicit human review points provide partial mitigations by increasing transparency and keeping humans in control of final actions, but any similar platform should adopt additional safeguards (e.g., sandboxed command execution, allow-lists, and policy enforcement) as advised in these studies.[^13][^28]

Design Principles to Borrow for a New Platform

1. Treat Paradigms as First-Class Concepts

BridgeMind’s separation of AI coding, vibe coding, and agentic coding clarifies user mental models and helps align features with expectations. A new platform can similarly define its own taxonomy (e.g., conversational prototyping vs. agentic refactoring vs. autonomous maintenance) and tie UX, docs, and pricing plans to these modes.[^2][^5][^3]

Useful inspirations:

Explicit naming of workflows ("vibe coding", "agentic coding") and clear tables comparing them to traditional development.[^3]
Guides that explain how these paradigms map onto concrete tools and flows, avoiding the sense of "just a generic AI wrapper".[^20][^5][^3]

2. Model Projects and Tasks as Central Entities

BridgeMind’s task-centric design (with status, instructions, and Task Knowledge) provides a strong abstraction for coordinating agents, humans, and external tools. For your own platform, treating tasks as first-class objects with a lifecycle and structured metadata enables:[^6][^4]

Easy multi-agent coordination via claim-and-work patterns.
Persistent shared memory that survives agent restarts.
Audit trails suitable for compliance and debugging.

This corresponds well with patterns in agentic programming where goal decomposition and task-level planning are essential.[^15][^12]

3. Build an Explicit Orchestration Layer

BridgeMCP and BridgeSwarm together form an orchestration layer separate from any single editor or agent. This aligns with industry recommendations to separate orchestration from model calls, enabling:[^4][^1]

Centralized control over tools, policies, and state.
Consistent task models across different clients (CLI, IDE, web, voice).
Easier evolution of orchestration logic without client updates.[^23][^27][^24]

Your platform could adopt a similar pattern: a central orchestrator (service or MCP-like server) exposing tools for projects, tasks, and agents, with thin clients on top.

4. Focus on Human-in-the-Loop Review and Guardrails

BridgeMind’s insistence that every task passes through human review before shipping is not just a safety statement but a product design choice: the lifecycle and APIs are engineered to make human approval the natural bottleneck. This mirrors empirical findings that agentic PRs are often acceptable but still benefit significantly from human oversight.[^29][^30][^6][^4]

For your platform, consider:

Making review states explicit in your data model.
Designing UI to make diffs, explanations, and rationales first-class.
Instrumenting logs and traces to support inspection and rollback.

5. Optimize for Flow-State and Reduced Context Switching

Vibe coding and BridgeSpace both emphasize reducing context switching: the builder stays inside one environment with terminals, tasks, agents, and lightweight editing, supported by themes and calm visual design. This is consistent with qualitative reports that multi-agent orchestration works best when orchestrators provide clear dashboards and minimal friction.[^17][^27][^2][^3][^1]

Conceptual inspirations:

Multi-pane layouts that keep key views visible: tasks, logs, editor, and agent status.
Warp-style command blocks or similar grouping to keep noisy logs manageable.[^1]
Configurable ambiance (themes, typography, noise levels) to support extended agentic sessions.

6. Treat Voice and Natural Language as Primary Interfaces

BridgeMind invests in voice (BridgeVoice) and natural language prompts as first-class input channels for coding, configuration, and orchestration. This aligns with research showing that natural language abstractions significantly improve LLM performance and usability for complex tasks.[^19][^9][^2][^3][^1]

Your platform could similarly:

Provide voice and text interfaces that compile into a shared internal task model.
Use natural-language agent configuration (prompt documents) rather than hard-coded routing logic.
Explore patterns where editing a Markdown file changes orchestration behavior, as seen in external orchestrator examples.[^22]

7. Embrace Explicit Roles and Multi-Agent Patterns

BridgeMind’s agents are configured with explicit roles (Architect, Frontend, Backend, Reviewer, QA, Coordinator, Scout) and operate under system prompts reflecting these responsibilities. This matches patterns in both research and industry where specialized agents with clear scopes outperform monolithic generalists.[^14][^11][^12][^17][^6][^1]

For your platform, consider:

Designing a role taxonomy aligned with your domain (e.g., Researcher, Synthesizer, Reviewer, Executor).
Using orchestration to coordinate these roles through phases and mailboxes.
Providing configuration UIs or DSLs for defining new roles.

Potential Gaps and Differentiation Opportunities

Deeper Policy and Security Layers

BridgeMind’s public materials focus more on productivity, orchestration, and experience than on explicit security controls beyond human review and local shell preservation. Research on agentic coding security points to additional needed measures such as:[^2][^4][^1]

Sandboxed execution for high-risk commands.
Static policies and allow-lists for tools and directories.
Automated detection and mitigation of prompt-injection and supply-chain attacks.[^28][^13]

A new platform could differentiate by making secure-by-design agent execution a core part of the architecture.

Stronger Testing and Regression Prevention

Research on Test-Driven Agentic Development (TDAD) shows that providing agents with pre-change impact analysis and targeted test contexts can significantly reduce regressions. While BridgeMind emphasizes tests conceptually, there is limited public detail on specific testing integrations and impact-analysis tooling.[^26]

Your platform could integrate:

Automated dependency graph generation between code and tests.
Pre-patch test selection and mandatory passes before tasks can be moved to in-review.
Agent skills that understand and leverage these graphs directly.[^26]

Richer Multi-tenant and Governance Features

Surveys and industry whitepapers suggest that enterprise agentic platforms must address governance: audit trails, RBAC, environment isolation, and cost management. BridgeMind’s current narrative is builder-centric rather than enterprise-governance focused.[^11][^24][^12]

A new platform could:

Provide fine-grained permissions and approval workflows.
Integrate cost dashboards and model usage policies.
Support multi-tenant isolation for teams and projects.

Conclusion

BridgeMind offers a clear, opinionated example of a modern agentic coding platform that combines conceptual clarity (vibe vs. agentic vs. AI coding), a strong task-centric orchestration layer (BridgeMCP + task lifecycle), and a native Agentic Development Environment (BridgeSpace + BridgeSwarm) designed to keep builders in flow while coordinating multiple AI agents.[^2][^6][^4][^1]

For architects designing a new platform, BridgeMind suggests several useful patterns: treat paradigms as first-class, organize around projects and tasks, build an explicit orchestration/service layer, enforce human-in-the-loop review, optimize for reduced context switching, and embrace explicit agent roles with multi-agent orchestration. At the same time, there is room to differentiate with stronger security, testing, and governance features informed by recent research on agentic programming, orchestration patterns, and AI coding security.[^27][^24][^17][^3][^6][^4]

References

BridgeSpace: Agentic Development Environment for Vibe Coding - Orchestrate AI agents across multi-pane workspaces, manage tasks visually, and ship entire products ...
BridgeMind: Vibe Coding & Agentic Coding Platform - The Agentic Stack. Use your favorite AI coding tools — BridgeMind connects them all through shared m...
What is Vibe Coding? Complete Guide | BridgeMind - What is Vibe Coding? Vibe coding is building software by describing what you want in natural languag...
BridgeMCP Documentation and API Reference - BridgeMind - BridgeMCP exposes 10 tools across three categories. Your AI agent calls these automatically when you...
What is AI Coding? A Guide for Builders | BridgeMind - AI coding shortens the distance between an idea and a working implementation. Builders use AI to sca...
Agentic Coding: Building with AI Agent Teams | BridgeMind - Here are the key principles ... Agentic coding is a software development methodology where AI agents...
[PDF] LLMs: A Game-Changer for Software Engineers? - arXiv - This allows LLMs to assist with software engineering tasks such as code generation, debugging, and e...
LLMs: A game-changer for software engineers? - ScienceDirect.com - This paper examines the transformative potential of LLMs in software development and argues that ear...
Natural language boosts LLM performance in coding, planning, and ... - Three new frameworks from MIT CSAIL reveal how natural language can provide important context for la...
Software engineering with LLMs in 2025: reality check - There's no shortage of predictions that LLMs and AI will change software engineering – or that they ...
Agentsway - Software Development Methodology for AI Agents-based Teams - The emergence of Agentic AI is fundamentally transforming how software is designed, developed, and m...
AI Agentic Programming: A Survey of Techniques, Challenges, and Opportunities - AI agentic programming is an emerging paradigm where large language model (LLM)-based coding agents ...
What Is Agentic Coding? Risks & Best Practices - Apiiro - Learn what agentic coding is, its key risks, and best practices to safely use autonomous AI agents f...
What is Agentic Coding? - IBM - As the term suggests, at the core of agentic coding are coding agents—AI systems that combine reason...
AI Agentic Programming: A Survey of Techniques, Challenges, and ...
Vibe Coding vs. Agentic Coding: Fundamentals and Practical Implications of Agentic AI - This review presents a comprehensive analysis of two emerging paradigms in AI-assisted software deve...
From vibe coding to multi-agent AI orchestration - CIO - Corporations integrated AI coding assistants to speed up prototyping, allowing lean staff to quickly...
What is agentic coding? How it works and use cases | Google Cloud - Explore the foundations of agentic coding, where AI agents execute workflows, allowing developers to...
Vibe Coding To $1M | Building Prompt Engineering Into BridgeSpace - ... bridgemind.ai Links BridgeMind Community (Join 7000+ Builders): https://bridgemind.ai/discord Br...
BridgeMind Enables Vibecoding with AI Agents - LinkedIn - Builders are shipping faster because the platform handles the execution while you focus on the logic...
Agentic Coding: Complete Guide to AI-Assisted D - TeamDay.ai - Master agentic coding with this comprehensive guide. Learn the patterns, tools, and best practices f...
Building a Multi-Agent AI System with Claude Code - Mae Capozzi - Learn how I built a Claude Code multi-agent orchestrator that coordinates specialized AI coding agen...
From AI Coding Agents to Multi-Agent Orchestration - LinkedIn - The evolution from individual AI coding assistants to orchestrated multi-agent systems represents bo...
AI Agent Orchestration Patterns - Azure Architecture Center - Learn about fundamental orchestration patterns for AI agent architectures, including sequential, con...
Context Engineering for AI Agents in Open-Source Software - GenAI-based coding assistants have disrupted software development. The next generation of these tool...
TDAD: Test-Driven Agentic Development - Reducing Code Regressions in AI Coding Agents via Graph-Based Impact Analysis - AI coding agents can resolve real-world software issues, yet they frequently introduce regressions -...
The Code Agent Orchestra - what makes multi-agent coding work - The orchestrator model gives you multiple agents with their own context windows, working asynchronou...
"Your AI, My Shell": Demystifying Prompt Injection Attacks on Agentic AI Coding Editors - Agentic AI coding editors driven by large language models have recently become more popular due to t...
On the Use of Agentic Coding: An Empirical Study of Pull Requests on GitHub - Large language models (LLMs) are increasingly being integrated into software development processes. ...
Agentic Refactoring: An Empirical Study of AI Coding Agents - Agentic coding tools, such as OpenAI Codex, Claude Code, and Cursor, are transforming the software e...