Skip to content
Published on

Cloud Dev Environments in 2026 — Codespaces / Gitpod Flex / Replit / StackBlitz / CodeSandbox / Bolt.new / v0 / Lovable Deep Dive

🇰🇷KO🇺🇸EN🇯🇵JA
Split View필사 모드
Authors

Prologue — the 2024-2025 cleanup season

One-line summary of the 2026 cloud dev environment market: the middle ground collapsed. April 2024 — Glitch closed signups under Fastly. July 2024 — AWS Cloud9 went new-customer-only-no. September 2024 — Gitpod sunset its Classic SaaS in spirit and pivoted to Gitpod Flex (self-hosted). December 2024 — CodeSandbox was acquired by Together AI and rebranded as "AI training compute." 2025 — JetBrains Space shut down.

What survived split into four lanes.

  1. Full-IDE clouds — GitHub Codespaces became the de facto standard, Replit doubled down on its AI Agent and closed a Series B, and Cursor Cloud arrived late. Gitpod Flex narrowed to self-hosted and survived.
  2. Browser-native sandboxes — StackBlitz's WebContainer normalized the miracle of running Node.js in the browser. CodeSandbox, under Together AI, became more about "safe code execution at scale for AI agents" than about end-user dev environments. val.town carved out the small but meaningful niche of "serverless functions written in the browser."
  3. AI-first builders — Bolt.new (StackBlitz), v0 (Vercel), Lovable, Magic Patterns. "One prompt → working app" became a validated workflow. The real work is now "prototype → port to real code."
  4. Open source / self-hosted — Daytona (OSS), DevPod (Loft Labs, OSS), Coder.com (enterprise self-hosted) settled in. github.dev / vscode.dev / Project IDX (Google) remain in the "lightweight option" bucket.

This piece compares 16 tools on the same axes and lays out what died, what survived, what is new. The last section is a decision tree across four scenarios — solo / team / demo / AI prototype.

Prices and feature numbers move fast. Everything in this piece reflects May 2026; the structural distinctions outlast the numbers.

1. A map of cloud dev environments in 2026 — four buckets

Same words, "cloud dev environment," but the four buckets differ in what exactly lives in the cloud.

Bucket A · Full-IDE cloud (remote VM + IDE bridge). The cloud holds an entire VM/container: OS, compilers, databases, IDE backend. The browser or local VS Code is a thin client. GitHub Codespaces, Replit, Cursor Cloud, Gitpod Flex (self-hosted) sit here. The devcontainer standard (.devcontainer/devcontainer.json) is the lingua franca. Pricing is per-hour CPU/RAM or monthly subscription.

Bucket B · Browser-native (no server). No server VM at all. Node.js or the runtime executes inside the browser. StackBlitz WebContainer is the flagship. CodeSandbox also uses browser runtimes for some flows. val.town is the hybrid case — author in browser, execute on serverless. Cost collapses to near zero, but you cannot do "real" builds (native deps, GPU).

Bucket C · AI-first builders. Not a code editor so much as a prompt-to-app pipeline. Bolt.new (StackBlitz), v0 (Vercel), Lovable, Magic Patterns. An LLM writes code on top of a browser-native runtime; humans inspect the result. The category exploded through 2025 and is now a real starting point for production codebases.

Bucket D · Open source / self-hosted. "Cloud" means our cloud. Daytona (OSS), DevPod (Loft Labs, OSS), Coder.com (enterprise). Dev environments live inside your VPC, your Kubernetes, your compliance perimeter. The customers are regulated industries, security-sensitive orgs, large engineering organizations.

Bucket E(?) · Lightweight editors. Less "environment," more "code only, in a browser." github.dev, vscode.dev, Project IDX (Google). Useful for quick PR review, ad-hoc edits, or Firebase / Google Cloud integration demos.

Different buckets need different axes of evaluation. Bucket A is a startup-time vs CPU-time tradeoff. Bucket B is "how real can it feel within browser limits." Bucket C is "prompt quality plus exportability." Bucket D is "operational burden vs compliance." Articles that try to rank all 16 on one axis usually mislead.

2. GitHub Codespaces — the biggest standard

By May 2026 Codespaces is the de facto standard for cloud dev environments. Three reasons.

First, the home of the devcontainer standard. .devcontainer/devcontainer.json is a Microsoft spec that GitHub helped popularize, and now Gitpod, JetBrains Gateway, and Cursor all read it. A well-built devcontainer.json now runs in four or five tools simultaneously. Lock-in risk to a non-standard format is low.

Second, GitHub integration. "Open in Codespaces" is a single click from any PR. Prebuilds make environments warm and ready by the time a PR opens. That alone is Codespaces' biggest weapon.

Third, the pricing makes sense. Roughly 0.18/hfor2−core/4GB,0.18/h for 2-core/4GB, 0.36/h for 4-core, $0.72/h for 8-core. Personal accounts get about 60 core-hours/month free. Large monorepos move to 16-core or 32-core.

The stack is Docker on Linux VM, composed from devcontainer features (installable units like languages, CLIs, tools). Dotfiles sync, secrets management (gh codespace secret), and prebuilds are the operational levers. Larger orgs standardize on "base devcontainer image plus team overlays."

Limits. GPU instances are restricted (added in late 2025, but limited and pricey). Slow prebuilds in big monorepos thrash with PR-triggered prebuilds and inflate costs. Network egress is reportedly expensive at scale. Org policies are powerful — and equally powerful at blocking everyone if misconfigured.

Comparison. The one-click PR environment experience is still best in class. Gitpod Flex can replicate it on self-hosted, with very different operational weight. Replit is closer to a solo developer; Codespaces is overwhelmingly a team tool.

3. Gitpod Flex (September 2024) — pivot to self-hosted

Gitpod was once the face of cloud dev environments. In September 2024 the team made what amounted to a sunset of their SaaS-first model. Classic stayed, but the new lineup, Gitpod Flex, was built around self-hosting (customer cloud / Kubernetes / on-premise). The reason was direct — enterprise customers wanted "code and secrets must not leave our perimeter."

Gitpod Flex's shape.

  • Control plane: Gitpod-managed (or optionally self-hosted).
  • Runner: lives in your cloud / Kubernetes. Code, secrets, and build caches stay in your perimeter.
  • Clients: browser (VS Code-based), local VS Code, JetBrains Gateway all connect.

devcontainer compatibility carried over. The difference is the data plane boundary.

Why the pivot made sense. Late 2024 / early 2025 usage data was clear. Small teams went to Codespaces; large teams wanted self-hosting. Gitpod's strength — "standardized workspaces with fast cold starts" — differentiates more in self-hosted (where Coder is strong on governance but Gitpod is ahead on workspace-definition standardization).

Pricing. Usage-based (hours × instance size) plus a control plane license. The SaaS price list is gone.

Who picks it. Regulated industries (finance, healthcare, public sector) needing data/secrets inside their own cloud perimeter. Large engineering orgs wanting a unified developer experience across multi-cloud.

Risk. The fast cold starts of the SaaS era now belong to your platform team. When a workspace fails to start, the first thing to debug is your EKS rather than Gitpod. Field reports point to one or two full-time platform engineers.

4. Replit + AI Agent — Series B

Replit closed a Series B through 2025 at a sharply expanded valuation. The weapon was Replit AI Agent. "Prompt to app, hook up a database in the same environment, deploy with one click." It exploded among solo developers, non-developers, and students.

Replit strengths.

  • All-in-one: editor, runtime, database (Replit DB / Postgres), deploy, domain, auth, payments. "Stack integration cost" is effectively zero.
  • AI Agent: beyond autocomplete, "add a feature → code + tests + DB migrations" in one flow. High autonomy with checkpoints / rollback.
  • Mobile friendly: practically the only place you can do serious coding on a phone.
  • Sharing / collab: Multiplayer mode. Great for student-mentor and interview coding.

Pricing. Free tier. Replit Core (paid individual) around $25/month. Teams per-seat. AI Agent calls billed separately (checkpoint-based).

Weaknesses.

  • Not a serious-engineering-org tool. Monorepos, big builds, complex CI feel cramped.
  • The most lock-in-heavy lane. Use Replit DB + Auth + Deploy and leaving is painful.
  • Compute is limited — no GPU, no large data processing.

Who picks it. Solo developers, indie hackers, non-developers / designers shipping a first prototype, education (students and instructors), interview environments.

Comparison. If Bolt.new / v0 / Lovable are "prompt to app" stage one, Replit owns stage two — operating the same app in the same environment. It blurs the line between the AI builder lane and the full-IDE lane.

5. StackBlitz WebContainer — fully in the browser

WebContainer was a technical shock. Compile Node.js to WebAssembly and run it inside the browser. No server VM. node index.js, npm install, vite dev — all run in the browser tab. Start time is 1-2 seconds. Cost is essentially zero.

Tech shape.

  • WebContainer API: Node.js + filesystem + shell inside the browser.
  • Networking: Service Worker intercepts and acts like a virtual server. localhost:3000 truly lives inside the tab.
  • Limits: native dependencies that need real Linux syscalls do not work (e.g. some sharp builds, parts of native SQLite). Python / Java / Go need separate WASM ports.

Who uses it.

  • Interactive examples in docs: many Vue / Nuxt / Astro / Vite official docs embed StackBlitz.
  • Repro reports: GitHub issues get a one-line "Reproduction here →" and you are done.
  • Tutorials / education: zero environment setup.
  • Bolt.new runtime: Bolt.new (StackBlitz's next chapter) runs on top of the same WebContainer.

Weaknesses. Big monorepos, native dependencies, GPU workloads, large build caches are out of scope. Service Worker constraints can bite at the edge. Safari compatibility is always the trickiest part.

6. CodeSandbox + Together AI (December 2024) — pivot to AI training environments

CodeSandbox was the mid-2010s icon — React demos, CSS Battle, the standard quick sandbox. In December 2024 it was acquired by Together AI and the identity shifted.

Why the acquisition? Together AI sells LLM training and inference by the GPU-hour. CodeSandbox brought (a) the behavioral data of millions of developers writing and running code daily, and (b) operational know-how for "safe code execution containers at scale, by the second." The second mattered more. AI agent training and evaluation made "safe code execution sandboxes" a critical cost and bottleneck — and CodeSandbox was one of the few companies that ran them well.

What changed.

  • For production users: the UI/UX held. The devbox (full Linux VM) and sandbox (browser runtime) workspace types continue to work.
  • New vision: positioning shifted to "safe execution environment for AI agents." An SDK lets other AI companies invoke CodeSandbox infrastructure to run code.
  • As a dev tool: new-feature announcements slowed. The message is "stable, plus AI infra-ification."

Who picks it. React/Vue quick demos still work great. New team adoption as a daily dev environment slowed. AI companies as SDK customers grew.

Lesson. An infrastructure-style startup pivoting from "selling directly to users" to "selling to other AI companies." The real value of CodeSandbox turned out to be not the UI but "safe-execution containers at thousands-per-second scale."

7. Glitch (April 2024, RIP) — the one we lost

Glitch was a warm icon of its era. It brought the word "remix" to coding, got Node.js apps live in 30 seconds, and was a "heaven for forgotten little projects." In April 2024 parent Fastly closed new signups and announced gradual reduction of operations.

Why it ended.

  • Business model strain: very high free-tier ratio, paid conversion never strong enough to sustain the business.
  • Infrastructure cost: "the heaven of sleeping small projects" sounds lovely, but waking and sleeping all those containers is a real ongoing cost.
  • Speed of the AI wave: at the same moment, Bolt.new / Replit AI / Cursor rapidly absorbed users.

What remained. Many broken "demo links," lost small learning projects, and the gap of a "kind coding environment." val.town picked up a piece, Replit a piece, Bolt.new a piece. None copy Glitch's warmth precisely.

Lesson. Free-tier-heavy workloads kill a company if the cost structure is wrong. Infrastructure-style businesses scale cost with active container count, not user count. And when a defining tool of an era dies, the gap is not perfectly filled.

8. val.town — serverless functions

val.town is a small company doing one clear thing. "Functions you write in the browser, deployed serverless instantly." It picked up part of the niche Glitch left behind — a home for small scripts.

Core idea.

  • Everything is a "val" — a function. HTTP handlers, crons, intervals, helper libraries — all functions.
  • Author in browser. Execute on serverless (Deno-based).
  • Vals can import from each other. A public library of vals grows like a tiny GitHub.

Why it is interesting.

  • "Remote functions update instantly." Save, live.
  • Secrets and env vars are first-class. Perfect for small integrations that need an API key or two.
  • Cron is first-class. The fastest way to build "run something at 9am daily."

Limits.

  • Not the environment for "a big app." Small integrations, bots, automations, demos.
  • Execution limits, cold starts, and external-call rate limits hit fast on the free tier.

Who uses it. Indie hackers, side-project builders, "Slack bot that does one thing," RSS-feed pipelines, "scrape data once, post to Slack" type jobs.

9. Daytona / DevPod — the OSS camp

The two open-source heavyweights of the self-hosted lane.

Daytona.

  • Full-stack self-hosted dev environment platform. AGPL.
  • Provider abstraction launches workspaces on Docker, Kubernetes, AWS, Azure, GCP, Hetzner, and more.
  • devcontainer-compatible. Codespaces-built devcontainer.json files run as-is.
  • IDE support: browser VS Code, local VS Code Remote, JetBrains Gateway all attach.
  • Differentiator: "my laptop, my server, our cloud, one interface." Strong fit for solo and small-team OSS users.

DevPod (Loft Labs).

  • "Codespaces, but client-side." Apache 2.
  • Core insight: workspace definition (devcontainer.json) is the standard; execution can happen "anywhere you have." Laptop Docker Desktop, internal Kubernetes, GCE VM — same workspace pops up.
  • No separate SaaS control plane. CLI-centric.
  • Loft Labs runs vCluster and DevPod together. Strong fit for Kubernetes-native orgs.

Comparison.

  • "Team / standardization / SaaS-like UI" — Daytona is a step ahead.
  • "My laptop, CLI-first, multi-backend" — DevPod is a step ahead.
  • Both are serious OSS alternatives to Codespaces / Gitpod Flex.

Risk. The eternal cost of self-hosted OSS — ops, backups, cost visibility, user support all become your job. Past 100 users, expect roughly one full-time platform engineer.

10. Coder.com — enterprise self-hosted

Coder is the most enterprise-leaning of the bunch. The identity is sharp.

Shape.

  • Coder control plane deployed into your Kubernetes.
  • Workspace templates written in Terraform. That is, "workspace = bundle of Terraform resources." Familiar to cloud IaC teams.
  • IDE support: browser code-server, JetBrains Gateway, local VS Code all attach.
  • Strong RBAC, SSO, audit logs, network policies. A fit for regulated industries, finance, public sector.

Business model. Open source core plus enterprise license. Large orgs buy enterprise.

Who picks it.

  • Engineering orgs with 1,000+ engineers, multi-region, multi-cloud.
  • Places that need audit trails of "which developer saw which code when."
  • Orgs whose security policy says "development can only happen inside the VPC / private network."

Versus Daytona / DevPod. Coder centers on "enterprise IaC + governance," Daytona on "workspace standardization + DX," DevPod on "multi-backend + CLI simplicity." Same self-hosted lane, three different problem framings.

11. JetBrains Space (RIP 2025) + AWS Cloud9 (RIP July 2024) — sunsets

Two large-camp sunsets. Both meaningful.

JetBrains Space — closed in 2025.

  • A bid to be "JetBrains' GitHub" — unified collaboration, issues, CI, packages, and cloud IDE.
  • Ambitious. But the market had already coalesced around GitHub + Jira + JetBrains Gateway + CircleCI / GHA.
  • JetBrains absorbed Space's core value (IDE backend, Code With Me, Gateway) into other products and shut Space down.
  • Lesson: "super-app" plays to capture an entire market almost always fail in already-standardized markets.

AWS Cloud9 — closed to new customers July 2024.

  • Acquired in 2017, it lived inside the AWS console as an IDE. New signups closed in July 2024.
  • AWS recommends "VS Code + your own instance + AWS Toolkit" as the path forward.
  • Lesson: big-company IDEs cannot keep pace with dedicated IDE companies. In the same window Codespaces, Cursor, and Gitpod evolved fast; Cloud9 stalled.

Lessons for the living.

  • The IDE market rewards "do one thing overwhelmingly well" more than "combine and integrate everything."
  • Even big companies cannot keep pace on an IDE — though Microsoft's Codespaces is the counter-example, riding on top of a separate VS Code team's velocity.

12. github.dev / vscode.dev / Project IDX — the lightweight options

Three tools that are less "full environment" and more "lightweight editor / demo."

github.dev.

  • Press . on github.com/foo/bar and you jump to GitHub.dev — same repo, in a browser VS Code.
  • No compute. No build, no test. Pure editor.
  • Good for fast PR review, one-line edits, viewing code on mobile.
  • Cost: zero.

vscode.dev.

  • Same tech, but extends to other workflows (open a folder, GitHub private repos, some extensions).
  • Extension sync with a Microsoft account.

Project IDX (Google).

  • Google's cloud IDE play. Nix-based environment definitions. Differentiated by Firebase, Google Cloud, and Android Emulator integration.
  • Serious about putting Flutter / Android development in the browser.
  • Moved from beta to GA over 2024-2025. Main audience: the Google ecosystem (Firebase, GCP, Flutter, Android).
  • Less a Codespaces-style general environment, more a "full-IDE cloud for the Google ecosystem."

Who uses these. github.dev — everyone, occasionally. vscode.dev — Microsoft camp users, occasionally. IDX — Flutter / Firebase developers, seriously.

13. AI builders — Bolt.new / v0 / Lovable / Magic Patterns

The fastest-growing category of 2025. "Prompt to app" became a serious tool.

Bolt.new (StackBlitz).

  • An LLM builds full-stack apps on top of WebContainer. Next.js, Svelte, Astro, and more.
  • Smooth flow: prompt to start → edit code directly → deploy.
  • Netlify deploy integrated. Push to GitHub.
  • StackBlitz owning WebContainer is the decisive weapon — more runtime control than the other AI builders.
  • Strength: really full-stack. Tailwind, shadcn, and modern stack defaults.

v0 (Vercel).

  • Started as "UI components (React + Tailwind + shadcn) generated." Through 2024-2025 it expanded into full-app territory.
  • Direct line to Vercel deploy. First-class with Vercel Postgres and Vercel KV.
  • Strength: the entire Vercel ecosystem is one click. Next.js generation quality is market-leading.
  • Weakness: non-Vercel deploys feel awkward. Opinions on "how much you lock yourself into Vercel" vary.

Lovable.

  • Full-stack app generation. Supabase integration is the strength.
  • "Database + auth + UI in one flow," very smooth.
  • Grew fast in 2024 with a strong indie-hacker fanbase.
  • Strength: Supabase backend integration is best in class. A real starting point for data-driven apps.
  • Weakness: scaling up to a bigger app puts code quality and exportability to the test.

Magic Patterns.

  • UI-design-first approach. Smooth "design → component" flow.
  • Figma-friendly. A bridge between designer and developer.
  • Where other AI builders chase full-stack, Magic Patterns deliberately stays on UI components.
  • Strength: designer-developer collaboration, starting point for a design system.
  • Weakness: backend needs another tool.

Common patterns.

  • "Prompt to working app" in 5-10 minutes.
  • But: it is a "starting point for a prototype," not "the destination for production."
  • Real businesses run the flow "start in AI builder → export code → port into a real IDE / CI."
  • Lock-in differs by tool. v0 (Vercel) > Lovable (Supabase) > Bolt.new (relatively neutral) > Magic Patterns (lightest, because it stops at UI).

14. Cursor Cloud — the newcomer

Cursor became the strongman of the IDE market. In 2025 Cursor Cloud arrived — the option to run Cursor's IDE backend in the cloud.

What is it.

  • Background agent work keeps running in the cloud even with the laptop closed.
  • Big monorepo indexing moves to cloud compute (offload local CPU).
  • Team-level workspace sharing.

Difference from Codespaces.

  • Codespaces puts "the whole OS + tools + execution environment" in the cloud.
  • Cursor Cloud puts "Cursor's agent backend + indexing" in the cloud. Code editing itself remains centered on the local IDE.
  • The two are complementary. Cursor Cloud + Codespaces stacked together is a valid setup.

Pricing. Add-on cloud compute fees on top of Cursor subscription. Usage-based.

Weakness. As a newcomer, operational stability data is still accumulating. Monorepo indexing freshness has occasional reports.

Who picks it. Teams already on Cursor company-wide, with big monorepos or long-running background tasks that benefit from cloud offload.

15. Korea / Japan — Toss, Kakao, Mercari

How three real companies run their dev environments tells you something the global tool benchmarks miss.

Toss. Strong on monorepo + in-house CI + internal deployment platform. More weight on internal standard environments (high-spec laptops + VPN + internal K8s + standard container image) than on external cloud IDEs. The standard is "a new hire can land their first PR within 30 minutes." Devcontainer is referenced, but the internal standard is separate. AI coding tools are adopted carefully under security / code-leakage policies.

Kakao. Security grades differ across Kakao / Kakao Bank / Kakao Pay. Kakao Bank, under financial regulation, leans self-hosted and internal-environment. Kakao HQ uses GitHub Enterprise + Copilot + internal tools. Both internal LLMs (KoGPT successor lines) and external models are evaluated. Cloud dev environments tend to be "team-by-team choice."

Mercari. One of the most modern engineering cultures in the Japanese market. Multi-cloud (GCP-centric) + Kubernetes-native. Serious about internal dev environment standardization. More aggressive about cloud IDE adoption than the Japanese market average. AI coding tool adoption is also faster than average. Japan's AI-builder and cloud-IDE markets trail the US by a beat, but Mercari, SmartHR, Cybozu and similar companies are moving fast.

Common Korea-Japan patterns.

  • Security and code-leakage policies are stricter than the US average. Long security reviews before adopting full-IDE clouds (e.g. Codespaces).
  • AI coding tool adoption is fast, but "code-training opt-out" is a first-tier checkbox.
  • Standard internal container image + devcontainer is the de facto pattern.

Takeaway. A global standard tool is not always the right answer. Regulation, language, and work style differences decide tool choice. The US-centric generalization "Codespaces is the standard" is only half-true in Korea / Japan.

16. Who should pick what — a decision tree

Same "cloud dev environment," different right answers by audience. Four scenarios.

Scenario 1 · Solo developer / indie hacker.

  • Fastest start, least ops: start with Replit or Bolt.new.
  • Tiny automation / Slack bot / cron: val.town.
  • Interactive demo / learning: StackBlitz.
  • Growing into a real codebase: move to GitHub, then Codespaces or local + Cursor.

Scenario 2 · Startup (5-50).

  • Standard: GitHub + GitHub Codespaces + devcontainer. One-click PR prebuilds save the most engineering time.
  • Tighter security: Gitpod Flex or Daytona self-hosted.
  • AI acceleration: each member picks one of Cursor / Claude Code / Codex CLI, plus shared Continue.dev for PR code review.

Scenario 3 · Enterprise (500+).

  • Governance / audit / regulation first: Coder.com enterprise.
  • Multi-cloud / Kubernetes-native: DevPod + Coder or Gitpod Flex.
  • Monorepo above 1,000 engineers: internal standard container image + Codespaces Enterprise or Coder. Two or three full-time platform engineers.
  • AI coding tools: start evaluating from options that support code-training opt-out. Enterprise contract + DLP + audit logs are required.

Scenario 4 · AI prototype / design-to-code.

  • UI components / design system: Magic Patterns or v0.
  • Full-stack quick prototype: Bolt.new or Lovable.
  • Data + backend in scope: Lovable (Supabase) or v0 (Vercel) or Replit.
  • After prototype validation: export code → GitHub → Codespaces / local + Cursor.

Anti-patterns of tool choice.

  1. Forcing one "standard" tool on everyone. Pushing Coder on a solo developer, or Replit on an enterprise, are both wrong.
  2. Treating AI-builder output as production code. A prototype is a starting point, not a destination. Code review, tests, and security review are required.
  3. Ignoring self-hosted ops cost. Daytona / DevPod / Coder all need ops headcount. Past 100 engineers, expect one FTE; past 1,000, expect two or three.
  4. Not using devcontainer. In 2026 devcontainer is the de facto standard. Staying on non-standard internal images makes tool migration painful.
  5. Not estimating lock-in cost. Deep integration with Replit DB, Vercel KV, or Supabase is convenient, but calculate "cost to leave" once.
  6. Saving security / compliance for last. In Korea / Japan / regulated industries, security review is step one of evaluation. Saving it for last means restarting from scratch.
  7. Throwing out local. Even with all the cloud dev environments, a good laptop with a fast local setup still wins many tasks. Mix-and-match is often the right answer.

Epilogue — what really changed in 2026

Five points to close.

1. The middle ground collapsed. Glitch is gone, Cloud9 is gone, JetBrains Space is gone. The survivors are at the poles — "biggest standard" (Codespaces, Cursor) or "clearest single thing" (val.town, Bolt.new).

2. Devcontainer became the real standard. The Microsoft-pushed, GitHub-popularized spec is now read by Gitpod Flex, Daytona, DevPod, Coder, and Cursor. A well-built devcontainer.json runs in five tools at once.

3. AI builders became real workflow. "Prompt to app" is no longer a joke. Bolt.new / v0 / Lovable / Magic Patterns are validated starting points. The real change is that "prototype to real code porting" became a job.

4. Self-hosted got strong again. The SaaS-only era ended. Gitpod Flex's pivot, the rise of Daytona / DevPod, and Coder's enterprise strength are the proof. Where data sovereignty, compliance, and cost visibility matter most, self-hosted is the answer.

5. Infrastructure-startup identity shifts. CodeSandbox being acquired by Together AI and pivoting to AI training infra is symbolic. The hard part of "selling directly to users" and the big opportunity of "selling infrastructure to other AI companies." Expect more of this over the next 1-2 years.

The tools keep changing. The buckets — full-IDE / browser / AI builder / self-hosted — will hold for a while. Inside them, who absorbs whom and who shows up next: that is the next 12 months' interesting story.

References

Discuss on Twitter • View on GitHub