It’s crazy to think that “vibe coding” started just weeks ago, with this tweet from Andrej Karpathy: 

Now, you can get a job as a vibe coder, and Stanford professors are giving lectures on it. That escalated quickly. 

In its short life, vibe coding has come to mean all kinds of AI-assisted workflows—especially ones where you let the model generate full chunks of your app and just roll with it. For non-devs, it opens a world of possibilities; even if you’re a professional dev, for building small side projects, learning something new, or just having fun, this is a great way to experiment. It’s fast, surprising, and often good enough.

But if you’re building something that actually needs to work—or scale, or be understood later—you’ll hit the vibes limits fast. You’ll start racking up bugs you didn’t notice, changes you can’t trace, and dependencies you didn’t mean to introduce. Vibes start shifting to bad vibes pretty quickly.

But don’t delete Cursor and reinstall plain ol’ VS Code just yet. There’s a better way to code with AI that keeps you, the developer, in control.

Enter Cursor Tab.

Sifting the Vibes to Tab Coding With Cursor 

Cursor Tab is an “autocomplete on steroids” feature in Cursor that goes beyond traditional code completion. Instead of working in the side pane with chat or the agent to write the code for you, Cursor Tab works with you as you write the code together.

Here’s an example. We have a class with a ton of todos. As we go into the code, the AI highlights what it thinks should be the next action to take:

All the user has to do is ‘tab’ and the code will be added:

Immediately, the next possible action will be shown, and the user can again tab to add:

But now, although the method in that class is complete, the AI doesn’t stop. Instead, it jumps ahead to the next method and is ready to add the code there:

And so on, always staying a step ahead of the user. 

Cursor Tab enables “tab coding.” Tab coding functions on two key principles:

1. Predictive coding. It acts like a fast colleague looking over your shoulder who can jump ahead and anticipate your next steps. Rather than just predicting characters after your cursor position, it predicts entire changes and where you’ll jump to next.
2. Zero-entropy edits. The system identifies actions that have zero entropy (are completely predictable once your intent is clear) and eliminates the need for you to manually perform these actions. Once you’ve expressed your intent, Cursor Tab handles the predictable parts for you.

Tab coding can be conceptualized as a predictive coding workflow. Repetitive and deterministic coding tasks—low-entropy actions—are identified and automatically completed or suggested by AI models activated by pressing tab. This approach abstracts coding into a streamlined, minimalistic, interaction-driven process, allowing developers to focus on higher-level logical and creative decisions.

At its core, tab coding:

• Eliminates repetition: Removes the necessity of manually typing predictable elements, thus saving developers time and mental effort.
• Maximizes predictive intelligence: Leverages advanced ML models to understand and anticipate programmers’ intent, guiding coding through logical “jumps” within or across files.
• Enhances user experience: Provides intuitive, context-aware UI elements (diffs, highlighting, interactive previews) to simplify reviewing and accepting changes.

The goal of tab coding is to reach a state where developers can interact with code through simple actions, reducing friction and cognitive overhead.

Cursor Tab in Action: Real-World Example

The above example is trivial—tab coding becomes much more important as the code grows. The AI is capable of ingesting the entire codebase and providing the “next logical step” predictive moves anywhere in it. 

Say you are building a SaaS tool on top of Neon and need to update a function that retrieves user data. You need to add location information to the response. You start by modifying the function signature:

// Beforefunction getUserData(userId) {  // returns { id, name, email }}// You change it tofunction getUserData(userId) {  // returns { id, name, email, location }

As soon as you add location to the return type comment, the AI highlights the implementation:

function getUserData(userId) {  const userData = db.query("SELECT id, name, email FROM users WHERE id = ?", [userId]);    return {    id: userData.id,    name: userData.name,    email: userData.email,    location: // AI highlight suggests: userData.location  };}

You press Tab to accept. The AI immediately recognizes that your SQL query doesn’t fetch the location column and highlights it:

const userData = db.query("SELECT id, name, email FROM users WHERE id = ?", [userId]);// AI highlights the query and suggests:const userData = db.query("SELECT id, name, email, location FROM users WHERE id = ?", [userId]);

You press Tab again to accept this change. The AI then jumps to where this function is used elsewhere in the code, highlighting places that need updating to handle the new property:

// In another fileapi.get('/user/:id', (req, res) => {  const user = getUserData(req.params.id);  // AI highlights the line below  res.json({ user: { id: user.id, name: user.name, email: user.email } });  // And suggests:  res.json({ user: { id: user.id, name: user.name, email: user.email, location: user.location } });});

With just three Tab presses, you’ve propagated your change through the entire stack—from response structure to database query to API response—maintaining consistency without switching contexts or having to remember all the places impacted by your change.

As you build with tab coding:

1. It understands your entire dependency graph. When implementing a new endpoint, tab will suggest imports from your existing database layer and utility functions, eliminating the context-switching that interrupts flow.
2. It handles cross-file implementation. After you define a new API route, pressing tab might offer to implement the missing database method in your repository file. Then, you might jump back to complete the controller logic, maintaining your mental model across the codebase.
3. It adapts to your coding patterns. If you’ve consistently implemented error handling, logging, and validation in a specific way, tab suggestions will follow those patterns, maintaining consistency without manual effort.

This human-AI collaboration approach keeps you in control while reducing cognitive load. Rather than generating entire applications in one go with unpredictable results, tab coding creates an interaction where you guide the AI through intentional implementation steps, making each tab press a deliberate extension of your intent.

The Technicalities of Cursor Tab

A few months ago, the Cursor team described how Cursor Tab worked at a high level to Lex Friedman. The technology combines several advanced AI and optimization techniques to deliver a responsive and intuitive coding experience.

Hierarchical model architecture

Cursor uses a sophisticated hierarchy of models where more capable “frontier models” handle planning and reasoning, while smaller specialized models handle implementation details. This creates a more efficient token economy and allows the system to scale effectively with complex codebases.

Sparse Mixture of Experts (MoE) models form the backbone of this architecture, making them ideal for Tab’s unique requirements. These models excel at processing huge inputs (your existing code) while generating relatively small, targeted outputs (the predicted changes). Cursor Tab models are specifically designed to handle very long prompts with extensive code context while generating relatively few tokens, making them “pre-filled token hungry.” This architecture perfectly suits the editing paradigm where context is vast but changes are precise.

Low latency optimizations

Speed is critical to the Tab experience, and several techniques ensure the system remains responsive:

• Specialized small models: These are specifically trained to handle high context requirements while maintaining speed, focusing only on the task of code prediction.
• KV cache optimization: Caching plays a crucial role in keeping Tab fast by preventing the need to rerun the model on all tokens with every keystroke, reusing computation where possible.
• Parallel processing: When using speculative edits, the system processes multiple lines of code simultaneously, significantly improving performance compared to token-by-token generation.

User experience enhancements

The technical capabilities are paired with thoughtful UX design:

• Streaming delivery: Rather than waiting for complete generation, the system streams suggested changes as they’re produced, allowing users to start reviewing immediately and eliminating frustrating loading screens.
• Custom diff interfaces: The team has developed 4-5 different visualization techniques optimized for different contexts:
  • Autocomplete diffs (focused on a single area)
  • Larger block review diffs
  • Multi-file diff visualization

Intelligent processing

The core of Tab’s intelligence comes from several advanced techniques:

• Speculative edits: This innovative variant of speculative decoding leverages existing code as a strong prior. The system feeds chunks of original code back to the model, which mostly agrees with it until reaching points requiring changes. This dramatically speeds up processing compared to generating each token individually.
• Caching-aware prompting: The prompts for the models are carefully designed to be “caching aware,” minimizing computational load and improving responsiveness by intelligently managing what context needs to be processed.
• Dependency graph understanding: The system builds a comprehensive understanding of your entire code dependency graph, enabling intelligent suggestions across files and components without requiring manual navigation.
• Adaptive pattern recognition: Cursor Tab learns and adapts to your existing coding patterns, maintaining consistency across your codebase by suggesting changes that align with your established conventions and style.

Cursor wants to take the Tab concept further, into a “next action prediction” generalization. Here, the next action wouldn’t stop at the code’s edge; instead, it would move into running commands in the terminal (you tabbed to add a new import, then you tab to npm install it) or tabbing into relevant documentation.

Empowering Developers Beyond Vibe Coding

In this way, tab coding is almost the antithesis of vibe coding—it wants the user to have the context, but it also removes the implementation friction. The model should provide knowledge, not just code. It’s about maintaining your agency as a developer while eliminating the tedious parts that drain your mental energy. There are no vibes, just intentional, predictable acceleration of your workflow.

If you’re building with Cursor, use Neon as the Postgres backend for your apps. We have an MCP server—read about it here.