How to Build With Agentic IDEs: Claude Code, Antigravity & uv

The three largest AI labs in the world just bought your developer tools. OpenAI acquired Astral (makers of uv and Ruff), Anthropic acquired the Bun JavaScript runtime, and Google DeepMind licensed Windsurf’s technology to build Antigravity—all within a nine-month window. This guide breaks down what each acquisition means for your actual workflow and shows you how to get hands-on with the new agentic development stack today.

What This Is

The acquisitions covered in Latent Space’s AINews mark a structural inflection point in developer tooling. For years, AI labs shipped models via API and let third-party tools—editors, runtimes, linters, package managers—handle the environment where code actually ran. That model is ending fast.

Anthropic + Bun (December 2025)

Anthropic acquired the Bun JavaScript runtime in December 2025. Bun is an all-in-one JavaScript runtime that replaces Node.js for many use cases: it handles package management, bundling, testing, and execution in a single compiled binary—and benchmarks consistently show it’s 3–5× faster than Node.js on cold starts. By owning Bun, Anthropic gives Claude Code its own optimized execution environment. As community commentary captured it at the time: “If Bun breaks, Claude breaks… Anthropic didn’t invest. they acquired. Vertical integration for ai tooling just started.” This means when you’re running Claude Code agents, you’re running on an Anthropic-controlled runtime stack—not a third-party dependency they can’t ship fixes for.

OpenAI + Astral (March 2026)

OpenAI acquired Astral, the company behind three tools that have quietly become the backbone of modern Python development:

• uv — A Python package installer and environment manager written in Rust, dramatically faster than pip and pip-tools
• Ruff — An extremely fast Python linter (also Rust), replacing flake8, isort, black, and pylint in a single binary for many engineering teams
• ty — A Python type checker competing directly with mypy

Python is the dominant language for AI, data science, and backend API development. Controlling the Python toolchain means OpenAI is embedded in every AI developer’s environment before they ever open a code editor or make an API call. This is a distribution play as much as it is a product acquisition. As the research report notes, uv has become “the most convincing solution for Python’s long-standing environment management fragmentation.”

Google DeepMind + Antigravity (July 2025 → 2026)

Google paid $2.4 billion to license Windsurf’s technology in July 2025, then built Antigravity on top of it. According to the research report, Antigravity represents an “agent-first mission control” philosophy. Rather than autocompleting lines of code, it manages entire project workflows. It runs on Gemini 3 Pro (Deep Think) with a 2-million-token context window and includes autonomous Chrome browser control, enabling end-to-end testing and web research without leaving the IDE. The term “PORK” (Proprietary Fork) has emerged to describe Google’s approach: taking a closed-source codebase and rebuilding it as a proprietary internal tool without the transparency of open-source forks.

OpenAI + OpenClaw + Promptfoo (February–March 2026)

OpenAI also acquired OpenClaw, a personal AI agent project by developer Peter Steinberger that went from a solo side project to acquisition in under 60 days—illustrating the extreme pace of M&A in this market. Sam Altman stated on February 15, 2026: “The future will be heavily multi-agent, and supporting open source is an important part of that.” OpenClaw was moved to an independent foundation. Additionally, OpenAI acquired Promptfoo, a tool over 25% of Fortune 500 companies were already using to stress-test AI implementations via automated red-teaming, integrating it into OpenAI Frontier for enterprise security.

Taken together, these moves represent what the research report calls the full transition from the “Chatbot Era” (assistive suggestions) to the “Agent Era” (autonomous execution). Labs are no longer just providing the brain—they’re building the body.

Why It Matters

This consolidation changes the leverage equation for every developer, agency, and enterprise team in three concrete ways.

Your toolchain is now a moat. When Anthropic owns Bun and OpenAI owns uv and Ruff, both companies can optimize the entire developer loop—from environment setup through code execution through agent task completion—in ways that third-party integrations cannot match. If you’re building on Claude Code, Anthropic can ship performance improvements at the runtime level that competitors simply can’t replicate on the same timeline.

Agentic autonomy requires infrastructure ownership. The research report identifies a core reason behind these acquisitions: as AI agents gain autonomous terminal and browser access, the reliability of the execution environment becomes existential. An agent that has to shell out to a third-party runtime it doesn’t control creates unpredictable failure modes. By owning Bun, Anthropic can instrument, sandbox, and harden the runtime Claude Code runs in.

The market is bifurcating by use case. Windsurf Pro, Claude Code, and Antigravity are not the same product aimed at the same audience. They represent three different philosophical bets on what agentic development looks like—and which bet your team makes has real workflow implications. Developers who pick the wrong tool for their use case will face compounding friction as these ecosystems diverge further.

Security is now table stakes. As the research report notes, agents with autonomous terminal and browser access expand the attack surface dramatically. Prompt injection—where a malicious input manipulates an agent into accessing sensitive data or disrupting automated workflows—is not a theoretical risk. OpenAI’s acquisition of Promptfoo and its integration into OpenAI Frontier signals that enterprise-grade agent deployments must include automated red-teaming from day one.

The Data

Critical Acquisitions and Strategic Moves (2025–2026)

Source: Latent Space AINews and research report

Comparative Analysis of Primary Agentic IDEs

Source: Research report

The context window gap is significant: Antigravity’s 2-million-token window can hold an entire large codebase in context simultaneously, making it uniquely suited for broad refactoring tasks or architectural reviews where Claude Code’s terminal-optimized approach would require chunking.

Step-by-Step Tutorial: Setting Up and Using the Agentic Dev Stack

This walkthrough covers three parallel tracks: setting up uv for Python-first teams, configuring Claude Code with Bun, and getting started with Antigravity for agent orchestration. Depending on your primary language and workflow, you’ll likely operate two of these three simultaneously.

Prerequisites

• macOS, Linux, or WSL2 (Windows)
• Git installed and configured
• A terminal emulator you’re comfortable with
• An Anthropic account (for Claude Code) or Google DeepMind Antigravity access (currently in limited preview as of March 2026)
• Basic familiarity with package managers (pip, npm, or Homebrew)

Phase 1: Replace pip with uv (OpenAI/Astral Ecosystem)

The first thing to do—regardless of which agentic IDE you use—is migrate your Python environment management to uv. This matters because AI coding agents generate dependency files and resolve packages as part of their autonomous task loops. A slow resolver is a bottleneck the agent hits on every task.

Step 1: Install uv

# macOS / Linux (curl installer)
curl -LsSf https://astral.sh/uv/install.sh | sh

# Or via Homebrew
brew install uv

# Verify installation
uv --version

Step 2: Create a new project with uv

# Initialize a new Python project
uv init my-agent-project
cd my-agent-project

# uv creates a pyproject.toml, .python-version, and src/ layout automatically
ls -la

Step 3: Add dependencies (the pip-free workflow)

# Add a dependency (resolves and installs in one step)
uv add anthropic

# Add dev dependencies
uv add --dev ruff pytest

# Sync the environment (equivalent to pip install -r requirements.txt)
uv sync

The key behavioral difference from pip: uv resolves the full dependency graph in a single pass using a SAT solver written in Rust. On a cold install of a typical ML project with 40+ dependencies, you’ll see resolution times drop from 30–90 seconds with pip to under 5 seconds with uv.

Step 4: Configure Ruff for linting

Since your agentic IDE will be generating Python code autonomously, you want Ruff running as a pre-commit gate to catch style and logic errors before they accumulate:

# Add Ruff configuration to pyproject.toml
cat >> pyproject.toml << 'EOF'
[tool.ruff]
line-length = 100
target-version = "py311"

[tool.ruff.lint]
select = ["E", "F", "I", "N", "W", "UP"]
ignore = ["E501"]

[tool.ruff.format]
quote-style = "double"
EOF

# Run Ruff on your project
uv run ruff check .
uv run ruff format .

Phase 2: Configure Claude Code with Bun

Claude Code runs as a terminal agent—you invoke it from the shell, give it high-level tasks, and it executes them using subagents that have access to your filesystem and terminal.

Step 5: Install Claude Code

# Install via npm (Bun runtime handled automatically by Claude Code's installer)
npm install -g @anthropic-ai/claude-code

# Or install Bun first if you want to run Claude Code on Bun directly
curl -fsSL https://bun.sh/install | bash

# Verify both
claude --version
bun --version

Step 6: Authenticate and configure

# Authenticate with your Anthropic API key
claude auth login

# Check configuration
claude config list

Step 7: Create a vibe profile

The research report notes that using a “vibe profile”—a structured document specifying your technical preferences, coding style, and architectural constraints—improves first-pass alignment by 27% compared to feature-only prompts. Create a CLAUDE.md file at the root of any project:

cat > CLAUDE.md << 'EOF'
# Project Vibe Profile

## Technical Stack
- Language: Python 3.11+
- Package manager: uv (NOT pip or poetry)
- Linter: Ruff (NOT flake8 or pylint)
- Test runner: pytest
- Type checking: ty (NOT mypy)

## Code Style
- Functions: snake_case, max 40 lines
- Classes: PascalCase, single responsibility
- Imports: always sorted (Ruff enforces this)
- Docstrings: Google style
- Line length: 100 characters max

## Security Constraints
- Never commit .env files or API keys
- All external HTTP calls must use httpx (not requests)
- Database queries must use parameterized statements

## Architectural Preferences
- Prefer composition over inheritance
- Keep side effects at the edges (functional core, imperative shell)
- Write tests before implementation when adding new modules
EOF

Step 8: Run your first Claude Code agentic task

# From your project root (with CLAUDE.md present)
claude "Audit the current codebase for any functions longer than 40 lines,
refactor them into smaller helpers, and run Ruff to verify the output is clean.
Generate a summary report of what was changed."

Claude Code will spin up subagents, scan your codebase, make the edits, run Ruff, and return a diff summary. This is where owning the Bun runtime pays off for Anthropic—the subagent orchestration layer runs on Bun, meaning Anthropic can ship latency and stability improvements to this layer without depending on Node.js release cycles.

Phase 3: Onboard to Google Antigravity

Antigravity is currently in limited preview. Access is being rolled out via the Google DeepMind developer portal. Assuming you have access:

Step 9: Install and launch Antigravity

Antigravity ships as a standalone application (not a VS Code extension). Download the installer from your DeepMind developer console, run it, and authenticate with your Google account that has preview access.

# After installation, launch from terminal
antigravity .

# Or open a specific project
antigravity /path/to/your/project

Step 10: Understand the Mission Control interface

Antigravity’s UI differs fundamentally from traditional IDEs. The left panel is a task queue—not a file tree. You delegate tasks to the agent rather than navigating files directly. Key interface elements:

• Task Delegation Panel: Where you describe high-level objectives
• Agent Activity Stream: Real-time log of what the agent is doing (file reads, terminal commands, browser actions)
• Human Checkpoint Gates: Points where the agent pauses and requires your sign-off before proceeding (configurable per-project)
• Browser Panel: Antigravity’s embedded Chrome instance, which the agent controls autonomously for E2E tests and web research

Step 11: Delegate an agentic task with checkpoint gates

Task: "Refactor the authentication module to use JWT tokens instead of session cookies.
Run the full test suite after each file change.
Pause and show me a diff before modifying any database migration files."

The agent will:
1. Read all files in your auth module (within its 2M token context window)
2. Identify all session cookie references
3. Generate a replacement plan
4. Execute file-by-file changes, running tests after each
5. Hit a checkpoint gate when it reaches migration files
6. Display a diff and wait for your approval before proceeding

This asynchronous delegation model is what the research report calls the shift from “developer as implementer” to “developer as Engineering Manager.”

Expected Outcomes

After completing this three-phase setup:

• Python dependency management will be 5–10× faster with uv
• Ruff will catch linting and formatting issues in milliseconds, not seconds
• Claude Code will respect your vibe profile and produce code that matches your stack conventions with measurably fewer correction cycles
• Antigravity will handle large-scale refactors asynchronously while you work on other tasks or review outputs at checkpoints

Real-World Use Cases

Use Case 1: Backend API Development Team (Claude Code + uv)

Scenario: A 4-person backend team maintaining a Python FastAPI service with 50+ endpoints needs to migrate from synchronous to async database calls—a change that touches hundreds of files.

Implementation: The team creates a shared CLAUDE.md vibe profile specifying their async preferences, their database ORM (SQLAlchemy 2.0), and their test framework (pytest-asyncio). They invoke Claude Code with a single task: audit all database call sites, identify blocking calls, and generate async equivalents. Subagents parallelize across modules.

Expected Outcome: A diff covering the affected files, organized by module, with Ruff-validated output ready for human review. The team shifts from writing the changes to reviewing them—the research report frames this as the core workflow shift of the Agent Era.

Use Case 2: Frontend Architecture Overhaul (Claude Code + Bun)

Scenario: A startup needs to migrate a React application from Create React App (CRA) to Vite. CRA is deprecated, but the codebase has 200+ components with non-standard import patterns.

Implementation: Since Claude Code now runs on Bun, JavaScript project tasks are natively optimized. The developer delegates: “Migrate this CRA project to Vite, update all absolute imports to relative paths, and verify the build succeeds.” Claude Code uses Bun’s native test runner to validate each module during the migration.

Expected Outcome: A complete Vite migration with zero manual file edits, completed in a single agent session.

Use Case 3: End-to-End Test Suite Generation (Google Antigravity)

Scenario: A SaaS company has an existing Playwright E2E test suite that covers only 40% of user flows. A QA engineer needs to expand coverage without writing each test manually.

Implementation: The engineer delegates to Antigravity with Chrome access enabled. The agent navigates the actual running application via its autonomous browser control, identifies flows not covered by existing tests, generates Playwright scripts, and executes them to verify they pass.

Expected Outcome: A set of new E2E tests generated from the agent’s actual navigation behavior—not from mocked interfaces—with coverage reports showing the delta. Antigravity’s 2M token context window means it holds the entire existing test suite in context while generating additions, avoiding duplication.

Use Case 4: Enterprise Security Red-Teaming (OpenAI Frontier + Promptfoo)

Scenario: A Fortune 500 company is deploying an internal AI agent that has access to HR records and financial data. Before production rollout, the security team needs to validate it cannot be manipulated into leaking sensitive data.

Implementation: Via OpenAI Frontier (which now integrates Promptfoo post-acquisition), the security team configures automated red-teaming workflows that systematically attempt prompt injection attacks, role-escalation prompts, and jailbreak attempts against the agent. The research report notes that over 25% of Fortune 500 companies were already using Promptfoo for this purpose prior to the OpenAI acquisition.

Expected Outcome: A vulnerability report identifying which attack vectors succeed, with remediation recommendations, integrated into the CI/CD pipeline so every future agent update is automatically red-teamed before deployment.

Use Case 5: Startup MVP at Zero Cost (Antigravity Free Preview)

Scenario: A two-person startup wants to build a functional B2B SaaS MVP in three weeks without hiring additional engineers.

Implementation: They use Antigravity’s free public preview (available through late 2026 before consumption-based pricing takes effect, estimated at $2–$15 per million tokens). The founders operate as Engineering Managers: writing architecture documents and vibe profiles, delegating implementation tasks to Antigravity, and reviewing outputs at checkpoint gates. Antigravity’s browser automation handles frontend QA.

Expected Outcome: A functional MVP at infrastructure cost only—no engineering salaries for the implementation phase. The startup gains the structural advantage the research report describes: “Startups can bypass legacy system friction by building their entire operational architecture around AI agents.”

Common Pitfalls

Pitfall 1: Skipping the Vibe Profile

The single most common mistake practitioners make when adopting agentic IDEs is deploying agents without a structured vibe profile. Without one, the agent defaults to its training distribution—which may produce perfectly valid code that doesn’t match your stack, your security constraints, or your naming conventions. The research report cites a 27% improvement in first-pass alignment when a vibe profile is present. Skipping this step means you’ll spend more time on correction cycles than on actual review.

Pitfall 2: Granting Agents Unrestricted Terminal Access

Antigravity and Claude Code both have default terminal and filesystem access. Deploying these in a production environment or against a database with write permissions, without sandboxing, is a material security risk. The research report explicitly identifies prompt injection as a live threat: a malicious input in a file the agent reads can redirect it to access sensitive data. Always run agents in a sandboxed environment with scoped permissions—read-only access to production data, no direct database write access, and explicit checkpoint gates before any destructive operations.

Pitfall 3: Treating Context Window Size as a Proxy for Quality

Antigravity’s 2-million-token context window is impressive, but more context doesn’t automatically mean better output. Dumping an entire monorepo into context without structure causes the model to weight irrelevant files alongside critical ones. Structure your context deliberately: use .antigravityignore files (analogous to .gitignore) to exclude build artifacts, node_modules, and binary files.

Pitfall 4: Not Integrating uv into CI/CD

Developers who adopt uv locally but leave their CI/CD pipelines using pip end up with environment inconsistencies. The uv resolver produces a lockfile (uv.lock) that pins the exact dependency graph. Make sure your CI pipeline uses uv sync --frozen to install from the lockfile, not pip install -r requirements.txt, which doesn’t enforce the same pinning guarantees.

Pitfall 5: Underestimating PORK Fragmentation

The “PORK” (Proprietary Fork) nature of Antigravity means its API surface and configuration format will diverge from Windsurf Pro over time. If you’re currently using Windsurf plugins or extensions, don’t assume they’ll work in Antigravity. Audit your extension dependencies before migrating.

Expert Tips

Tip 1: Use Subagent Modularity in Claude Code for Parallelism

Claude Code supports specialized subagent modularity. For large tasks, explicitly decompose the work into parallel subagent calls rather than issuing a single monolithic task. For example, instead of “refactor the entire codebase,” issue three simultaneous tasks: “refactor the auth module,” “refactor the API layer,” “refactor the data models.” This parallelism can cut wall-clock time on large tasks by 50–70%.

Tip 2: Standardize Vibe Profiles Across Your Engineering Org

Once you’ve validated your vibe profile on one project, commit it to a shared internal repository and reference it in every new project’s CLAUDE.md. Standardizing architectural guidelines across your organization reduces the number of AI hallucinations that violate corporate security or styling standards—this is exactly the pattern the research report recommends for enterprise leadership.

Tip 3: Pin Ruff’s Version in pyproject.toml

Ruff updates rapidly—and occasionally introduces new lint rules that flag previously clean code. Pin the Ruff version in your pyproject.toml under [tool.uv.dev-dependencies] and treat Ruff upgrades as a deliberate migration, not a passive dependency update.

Tip 4: Use Antigravity’s Browser Automation for Regression Testing, Not Feature Discovery

Antigravity’s autonomous Chrome control is most reliable when navigating known user flows that you can specify with precision. It’s less reliable when used for open-ended “explore the app and find bugs” sessions—hallucinated navigation paths are a real failure mode. Use it to systematically cover your documented user stories, not to replace exploratory QA.

Tip 5: Monitor OpenAI Frontier Pricing Before Scaling Promptfoo Red-Teaming

Automated red-teaming via Promptfoo in OpenAI Frontier is token-intensive—each attack scenario generates multiple model calls. Before you configure aggressive red-teaming schedules in CI/CD, establish a per-run token budget and set alerts. A misconfigured red-team pipeline running against a large agent on every commit can generate significant costs quickly.

FAQ

Q1: Should I migrate my entire Python project to uv right now, or wait?

Migrate now for new projects and start migrating active projects immediately. The uv resolver is backwards compatible with pyproject.toml and requirements.txt files—migration is mostly dropping in uv sync in place of pip install. The performance gains are real and immediate, and as OpenAI integrates uv deeper into its agentic stack, projects using it will get tighter first-party optimization over time. The primary risk is CI/CD pipelines that haven’t been updated—address those before switching the local environment.

Q2: Is Antigravity available to everyone, or only enterprise customers?

As of March 2026, Antigravity is in limited public preview via the Google DeepMind developer portal. The research report indicates that full public availability with consumption-based pricing (estimated $2–$15 per million tokens) is expected in late 2026. The free preview is the window to build with it at zero cost.

Q3: What’s the practical difference between Claude Code and Windsurf Pro for day-to-day development?

Claude Code is terminal-first: you drive it via shell commands, pipe outputs, and script complex multi-step workflows. It’s best for backend and DevOps engineers who live in the terminal. Windsurf Pro is editor-first: it provides real-time inline suggestions and its “Supercomplete” feature predicts entire function implementations. It’s better for senior engineers who want to stay in a flow-state code session. Per the research report, the recommended hybrid is using Windsurf Pro for rapid feature development and Claude Code for large refactoring or infrastructure tasks.

Q4: How does Promptfoo’s red-teaming integrate with my existing CI pipeline?

Promptfoo supports both CLI and programmatic usage. You add a promptfoo eval step to your CI pipeline that runs your configured test scenarios against the agent. Post-acquisition, OpenAI has integrated Promptfoo into OpenAI Frontier’s enterprise dashboard with automated compliance reporting. For teams not on Frontier, the standalone Promptfoo CLI remains available and still functions independently.

Q5: What is “vibe coding” and is it actually different from prompt engineering?

Yes—meaningfully so. Prompt engineering is about crafting individual inputs to get better outputs from a model. Vibe coding, as defined by Andrej Karpathy, is a complete development paradigm: “Building fully functional applications using high-level prompts that describe outcomes, constraints, and interaction patterns… natural language becomes the primary interface, not a supplement.” The difference is scope. Prompt engineering optimizes a single interaction. Vibe coding restructures the entire development workflow so the human role shifts from implementation to architectural direction and output review.

Bottom Line

The acquisitions of Astral, Bun, Windsurf, OpenClaw, and Promptfoo represent the formalization of vertical integration in AI development tooling. Labs are no longer competing only on model quality—they’re competing on who owns the end-to-end developer loop from environment setup through autonomous code execution through security validation. For practitioners, the immediate action items are clear: migrate Python projects to uv, create standardized vibe profiles for every project using Claude Code, request access to Antigravity’s preview for large-scale refactoring tasks, and integrate Promptfoo-style red-teaming into any agent deployment that touches sensitive data. The research report puts it plainly: leaders who are not asking “which workflows should no longer require human coordination?” today will be asking it in two years when the competitive gap has already opened.