Cursor's June Offensive: 3 Major Versions in One Month

Three major versions in one month, each roughly four days apart. That's not iteration — that's a statement. Cursor shipped v3.7, v3.8, and v3.9 across June, and the cumulative effect is bigger than the sum of those releases. The company isn't competing on autocomplete quality anymore. It's building the substrate for an entire AI programming ecosystem.

If you've been using Cursor as a smart editor, you should start using it as a platform. The June releases explain why.

What actually changed in June

Most AI coding tools release in two rhythms: small weekly tweaks and big quarterly drops. Cursor broke the cadence. v3.7 dropped on the 14th, v3.8 on the 18th, v3.9 on the 22nd. Each release carried feature weight that, on its own, would have justified a minor version bump from most vendors. Together they form a coherent platform thesis — the same one the original June writeup lays out: three pillars, mapped one-to-one onto the three releases.

Compute layer (v3.7, June 14). The internal scaffolding that handles AI-driven code generation, context retrieval, and resource management. Less visible to end users, more visible in latency and cost. The June 14 release anchored this layer.

Automation layer (v3.8, June 18). Cursor Automations and the new /automate command land here. Repetitive coding workflows — PR reviews, code formatting, dependency updates, test suites — get defined as automation rules, triggered by events like Slack emoji reactions. This is the first time Cursor's automation has felt like a real product surface rather than a script repo.

Ecosystem layer (v3.9, June 22). The big one. Plugins, skills, and MCP (Model Context Protocol) used to live in three separate entry points. v3.9 collapses them into a single interface, adds a Marketplace leaderboard that surfaces quality plugins, and ships reusable plugin canvases so teams can package common workflows as one-click templates. Direct import support for GitLab, BitBucket, and Azure DevOps closes the last mile for enterprise multi-repo setups.

This is what platformization looks like in 2026. Not a single killer feature — a stack.

[[COMPARE: AI code editor vs AI programming platform]]

The bet behind the releases

Cursor's thesis, stated plainly: AI coding tool ecosystems have always been fragmented. Every vendor has plugins, but discovery, installation, management, and sharing lack unified standards. Whoever brings MCP protocols, custom skills, and third-party plugins into one competitive Marketplace first reaps the network effects earliest.

That bet looks like it's paying off. The Marketplace leaderboard is a small detail with a big effect — it gives plugin authors a reason to compete on quality rather than SEO. The plugin canvas system gives teams a way to standardize internal workflows without forking a config repo. And MCP integration means the same plugin can be reused across Cursor and any other MCP-aware tool that comes next.

For enterprise teams sitting on the fence, the GitLab / BitBucket / Azure DevOps import support is the psychological threshold. Trial becomes deployment once your existing repo infrastructure is a one-click import away.

How to actually use this today

The marketing framing is "platform." The day-one usage is more concrete. Four things worth turning on this week.

1. Wire up /automate for one repetitive workflow

Open the command palette and run /automate. The first time you use it, Cursor asks you to define a workflow. Start with the most boring thing on your team's plate — usually dependency update PRs or test suite reruns on flaky files. The Slack-emoji trigger is the underused one: drop a :white_check_mark: on a message in #releases and it kicks off the build, runs the test suite, and posts back the result. PR review becomes a reaction.

# Schematic: a /automate rule for nightly dep updates
# (exact schema may differ — see Cursor's /automate docs for the current spec)
name: nightly-deps
trigger:
  schedule: "0 2 * * *"
  on: slack
  channel: "#eng-bots"
  emoji: ":arrows_counterclockwise:"
actions:
  - run: "gh pr create --base main --head deps/auto --fill"
  - notify: "PR opened: $PR_URL"

2. Browse the Marketplace leaderboard

Inside Cursor, hit the plugin panel and switch to the Marketplace tab. The leaderboard sorts by usage, retention, and review signals — not by author reputation. That matters: it makes the leaderboard harder to game than a curated store. Spend ten minutes installing the top three in your category (likely an MCP server, a testing helper, and a linter integration) and measure whether the onboarding time paid off.

3. Build a reusable plugin canvas for your team

Plugin canvases are the most underrated feature in v3.9. A canvas is a saved bundle of plugins + skills + MCP servers + a launch prompt, packaged as a one-click install. For teams, this is the answer to "why is my laptop configured differently from yours."

// Schematic: a Cursor plugin canvas
// (see Marketplace docs for the current spec)
{
  "name": "frontend-starter",
  "version": "1.0.0",
  "plugins": ["eslint-mcp", "storybook-helper", "vitest-runner"],
  "skills": ["react-server-components", "css-modules"],
  "mcp_servers": ["figma-bridge", "linear-context"],
  "entry_prompt": "I'm working on a frontend ticket in $LINEAR_URL"
}

Check the canvas into your monorepo as cursor.canvas.json. New hires clone, install, and they're at parity with the senior engineer who built the canvas.

4. Import a non-GitHub repo

If your team is on GitLab, BitBucket, or Azure DevOps, the v3.9 import flow is the moment of truth. The direct import closes the gap that historically made Cursor feel like a GitHub-first tool — clone, index the default branch, surface existing PRs and issues, wire MCP context for the import source. For an enterprise procurement committee, this is the checkbox that moves Cursor from "interesting tool the devs are trying" to "approved platform."

What this gets us

Three concrete enables from the June releases:

• Workflows as code. /automate and plugin canvases let a team encode its conventions once and ship them to every developer. The convention is the documentation. The documentation doesn't drift.
• Plugin economics. The leaderboard creates a market signal. Authors compete on retention, not on how loud their launch tweet was. The plugins that win are the ones that survive Monday morning.
• Ecosystem portability. MCP integration means a plugin you build for Cursor can be served to Claude Code, Windsurf, or whatever the next editor is. The work you do in the platform layer is portable; the work you do in the editor layer is not.

The part that doesn't change when the editor does

Here's the thing about platform bets: the platform layer moves fast. Cursor in June 2027 will not look like Cursor in June 2026. The compute layer, the automation triggers, the Marketplace curation — all of it will iterate. The plugin canvas format will change. The /automate syntax will evolve. MCP itself is a 2024-vintage protocol that will almost certainly be replaced by something cleaner by 2028.

The part that doesn't change is the interface the user actually touches. The button, the form, the screen layout, the navigation pattern. When you ship a cross-platform app, the UI primitives you build today need to survive the editor churn underneath them. The same component has to look and behave the same on web, iOS, and Android — one API, three render targets — and it has to keep doing that when the underlying tooling swaps out from under you.

Cursor is a great place to build inside. It's not the surface your users see. The surface your users see is the component layer, and that layer is the part worth investing in once.

Closing

Cursor's June was impressive. Three major versions in a month, each one with real features, all of them cohering into a platform story. If you're already on Cursor, the v3.9 update is worth an hour of exploration — the Marketplace leaderboard, the plugin canvases, and the multi-vcs import together are a meaningful shift in what the tool can do for a team.

The durable lesson: build on the platform, but own the interface. The platform will churn. The interface is yours.