标签：#cursor

In this week’s episode of Build Mode, Isabelle Johannessen talks with Precursor Ventures' Charles Hudson about the headwinds facing early-stage founders today and the most common mistakes founders should avoid in order to get funded.

Cursor has launched a new mobile app for remote oversight over coding agents.

When I first started using Cursor AI , I thought it was just an AI-powered code editor. After spending more time with it, I realized it's much more than that. Cursor isn't just about generating code—it's a development assistant that can understand your project, automate repetitive tasks, connect with external tools, and help you build software much faster. If you're new to Cursor, this guide will explain the most important concepts in simple language with real-world examples. 1. What are Rules? Think of Rules as permanent instructions for Cursor. Instead of telling the AI the same things every time, you define them once and Cursor follows them throughout your project. Example Instead of writing this every time: Use TypeScript Use Tailwind CSS Create reusable components Write clean code You can create a rule like: Always use TypeScript. Always use Tailwind CSS. Never use inline CSS. Create reusable components. Write meaningful comments. Now every prompt automatically follows these instructions. Real-world example Imagine you're working in a company where every developer follows coding standards. Rules are those standards—but for your AI assistant. Benefits Consistent code Less repetitive prompting Faster development Better code quality 2. What are Skills? Skills are reusable instructions for specific types of work. Instead of explaining how to build an API every time, you create one reusable skill. Example: Create Express APIs using MVC architecture. Validate all inputs. Handle errors properly. Use async/await. Now whenever you ask Cursor to create an API, it follows that workflow. Real-world example A plumber has plumbing skills. An electrician has electrical skills. Similarly, Cursor can have reusable development skills. Benefits Reusable workflows Consistent architecture Faster feature development 3. What are Hooks? Hooks are automatic actions triggered by an event. For example: You save a file. ↓ Cursor automatically runs: Formatter Linter Tests You don't have to

Every weekday a single, opinionated rule for senior C#/.NET engineers using Cursor. Here's the full week in one read — canonical posts live on the Agentic Architect blog . 7 daily senior rules Rule 14: Sealed By Default Sun 21 Jun Mark every class sealed unless inheritance is explicitly planned. Stops Cursor inventing accidental inheritance hierarchies "for flexibility." Small but measurable virtual-call perf wins too. → Permalink on the blog Rule 13: Strongly-Typed IDs Sat 20 Jun OrderId as record struct OrderId(Guid Value) beats raw Guid everywhere. Stops the AI passing a CustomerId where an OrderId was expected — a bug the compiler can't catch with primitive obsession but catches instantly with domain primitives. → Permalink on the blog Rule 12: IOptionsSnapshot Over Raw Config Fri 19 Jun Business code should never call IConfiguration directly. Strongly-typed IOptions or IOptionsSnapshot bindings only. The AI loves to "just grab the config value" — refuse it and force a settings class with validation attributes. → Permalink on the blog Rule 11: Rethrow, Don't throw ex Thu 18 Jun throw ex resets the stack trace. throw preserves it. Cursor gets this wrong about 40 percent of the time when generating catch blocks. Rewrite any naked throw ex to throw unless the exception has been explicitly wrapped. → Permalink on the blog Rule 10: AsNoTracking for Reads Wed 17 Jun Every read-only EF Core query should call AsNoTracking. Add a rule that recognises query methods returning DTOs (not entities) and inserts the call. Cursor never does this by default and your read perf degrades silently across releases. → Permalink on the blog Rule 9: Scoped Capture in Singleton Tue 16 Jun The single most expensive .NET runtime bug: a Singleton holding a Scoped service. Cursor cheerfully writes this without warning. Audit constructor parameters of any class registered as Singleton — if any are typically Scoped (DbContext, repositories, MediatR sender), flag it before merge. → Permalink on

📝 Originally published in Japanese on Zenn. This is the English version. Canonical: https://zenn.dev/uya0526_design/articles/satellite4_ai-collaboration 📚 This is satellite article #4 (the finale) in my "Read-Aloud Speed Meter dev log" series. For the whole picture, see the main article . Where This Sits The read-aloud speed meter was the first project where I adopted "AI-collaborative development" as an explicit mode. Until then, my learning style was "I write all the code myself; AI is a reviewer." With a contest deadline looming, I stepped one notch further. This article isn't a technical deep dive — it's a reflection on the development style itself. Three things: The reframe from "did you use AI" to "are you the one driving" The stumbles I actually hit in AI collaboration, and the patterns I pulled out of them Why rejecting an AI suggestion was the single most important thing 💡 This is a record of an ex-Java SE engineer learning TypeScript and Python in public. It's less a technical article and more a reflective, prose-y piece on the development process. I Switched Styles My learning articles have always run on a rule: I write the code myself; I use AI for hints, spec clarification, and bug spotting. Typing every word myself had learning value. This time there was a contest deadline, and a huge amount to cover. So I switched into a collaborative mode: AI demonstrates boilerplate (recording, fetch, API Route skeletons), and I handle the conceptual core and the design decisions. The awkward part was how to disclose that in the article. I'd publicly stated my AI use for code before, but this time I collaborated with AI on the article's outline, structure, draft prose, and even translation. In a contest with money (a prize) on the line, blurring that didn't feel honest. At first I framed it as "using AI is no different from accepting an IDE's autocomplete." But that was inaccurate. Autocomplete ≈ word/line-level completion This time ≈ delegating outline, structure,

Separately, neither could compete. Now they hope they can.

The deal is supposed to help SpaceX's struggling AI division. The company told IPO investors it sees a $26 trillion addressable market in AI.

This article was originally published on aicoderscope.com TL;DR : Gemini 3.5 Flash went GA on May 19, 2026 and costs 50% less than Claude Sonnet 4.6 on input tokens ($1.50 vs $3.00/M). It generates code at ~284 tokens per second — roughly 4.7× faster than Sonnet 4.6. Cursor already lists it natively; Cline needs one extra config step. The trap: Flash's default thinking level is "medium," which is slower and pricier than "low," the setting Google specifically tuned for coding and tool-use loops. Gemini 3.5 Flash Claude Sonnet 4.6 DeepSeek V4-Flash Best for Fast agent loops, context-heavy analysis Complex refactors, instruction fidelity Cost-capped high-volume tasks Input / Output per 1M tokens $1.50 / $9.00 $3.00 / $15.00 $0.14 / $0.28 Context window 1M tokens 200K tokens 1M tokens Terminal-Bench 2.1 76.2% — — Output speed ~284 t/s ~60 t/s — Max output per request 65,536 tokens 64K tokens 64K tokens The catch Output at $9/M erodes savings on code-gen 15× pricier output than Flash No vision, MIT-licensed Honest take : Use Gemini 3.5 Flash with Cline for multi-step agent tasks where round-trip latency compounds and context windows run large. Stay on Claude Sonnet 4.6 when you need a hard refactor to land perfectly on the first try — Sonnet's 79.6% SWE-bench Verified score still leads Flash's on correctness benchmarks. The cost math that does and doesn't work Gemini 3.5 Flash charges $1.50 per million input tokens and $9.00 per million output tokens. Against Claude Sonnet 4.6 at $3.00/$15.00, the input side is a genuine 2× saving. The output side is almost the same story: $9 vs $15 is 40% cheaper per generated token. Run the numbers on a typical Cline coding session: 8 tool calls, reading 12 files (roughly 20,000 context tokens), generating 500 lines of code output (~7,000 output tokens). Sonnet 4.6: (20K × $3 + 7K × $15) / 1,000,000 = $0.165/session Gemini 3.5 Flash: (20K × $1.50 + 7K × $9) / 1,000,000 = $0.093/session That's 44% cheaper per session. At 50 sessions a m

This article was originally published on aicoderscope.com TL;DR : Cursor Tab (the inline ghost-text autocomplete) breaks in 8 distinct ways. Roughly 70% of cases are fixed in under a minute by checking three things: the toggle in Settings, your extension list for Copilot, and your usage quota. The remaining 30% need a corporate proxy fix or a toggle-restart cycle. After this guide you will: Know which of the 8 root causes matches your specific symptom Have the exact settings path and command for each fix Understand the 2,000-completion monthly cap on the Hobby plan that silently kills suggestions at month-end Honest take : Every "Cursor Tab is broken" thread in 2026 falls into one of these eight buckets. Go through the three-step quick check first — most readers fix it there. The 60-second triage: three checks before anything else Open Cursor and verify these in order. They resolve 70% of cases. 1. Is Cursor Tab actually enabled? Press Ctrl+Shift+J (Windows/Linux) or Cmd+Shift+J (Mac) to open Cursor Settings, then go to Features > Cursor Tab . The toggle should be on. If it's off — and this happens more than it should after updates — flip it, restart Cursor, done. You can also check from the status bar at the bottom right of the editor. A small "Tab" indicator shows whether inline completions are active. If it shows disabled, click it to re-enable. 2. Have you hit the free quota? On the Hobby plan, Cursor gives you 2,000 tab completions per month . During active coding at a normal acceptance rate, you can burn through 50–100 per hour. If you're late in the billing cycle, open Settings > Usage & Limits and check the completions counter. Completions reset on your account anniversary date, not the calendar month. When you hit 2,000/2,000, tab completion stops silently — no error, no banner, just nothing appearing. Upgrade to Pro ($20/mo) or wait for the reset. 3. Is GitHub Copilot or Tabnine installed? If you migrated from VS Code with extensions intact, you may have G

If you use Cursor, Claude Code, or Windsurf daily, you've probably had this experience: You open a fresh chat, ask for a small fix, and twenty minutes later the AI has rewritten your API layer, added three new dependencies, and switched your data-fetching pattern "for consistency." The model isn't broken. It's contextless. Every new session starts from zero. It doesn't know your stack, your conventions, or the things it must never touch. So you spend the first ten minutes re-explaining — and the last hour undoing. Here's what fixed it for me. The real problem isn't prompts Most devs collect prompts. Notes app, Slack snippets, old chat threads. That helps for one-off tasks, but it doesn't solve the session problem. What you need is persistent context — rules that load automatically before you type anything. Two files do this: CLAUDE.md — read by Claude Code (and usable as project context elsewhere) .cursorrules — loaded by Cursor on every session (rename to .windsurfrules for Windsurf) Drop them in your project root. Done. What goes in a good config file A useful config is not ten lines of "use TypeScript and write clean code." That's too vague to change behavior. Mine include: Project structure — where pages, components, and API routes live Stack + versions — Next.js 14 App Router, not Pages; Zod; shadcn/ui Commands — npm run dev, npm run typecheck, npm run test Coding conventions — naming, import aliases, Server vs Client Components DO NOT section — the most important part (more on this below) Workflow notes — use @folder, prefer editing existing files, minimal diffs Here's an excerpt from the DO NOT section that saved me the most time: DO NOT — Critical Anti-Patterns Do NOT create a pages/ directory or use the Pages Router Do NOT rewrite the entire API layer — extend existing route handlers Do NOT add new npm dependencies without stating why Do NOT make drive-by refactors in unrelated files Do NOT fetch data in useEffect when Server Components can fetch directly T

This article was originally published on aicoderscope.com In early 2023, Andrej Karpathy coined the term "vibe coding" to describe a new mode of software development: you describe what you want, the AI writes the code, and you ship without reading every line. He meant it as a genuine observation about where the craft was headed. By 2026, vibe coding is the default mode for most solo developers, with AI tools handling roughly 70% of keystroke work on a typical feature. The other 30%—direction, review, judgment—still belongs to the human. The pitch is real. Solo developers can now build features that would have taken a week in a day. The bottleneck isn't code volume anymore; it's knowing what to build. That's a genuine productivity unlock. The problem is also real. Codebases vibe-coded without guardrails develop a specific pathology: inconsistent patterns across files (because each AI session starts with no memory of the last), logic errors masked by plausible-looking code, and no rollback culture because no one committed before letting the AI loose. The developer who vibed their way through six weeks of feature work often can't explain what the codebase does anymore, because they never had to think through it. This guide is not about slowing down. It's about the ten rules that let you keep the speed without the debt. The Promise vs. the Reality What vibe coding looks like in 2026: you open Cursor, describe the feature in natural language, and Agent mode writes the file. You review the diff, accept what looks right, reject what looks wrong, and move on. For standard CRUD features, state management, boilerplate API clients, and UI components, this works well. The AI has seen enough patterns that its output is often correct on the first try. Why it works especially well for solo devs: there's no code review bottleneck. A team has to slow down to onboard the AI's changes into shared mental models. A solo developer owns the whole context and can iterate without waiting fo

This article was originally published on aicoderscope.com On paper, Windsurf and Cursor are the same product. Both are standalone IDEs forked from VS Code. Both charge $20/month for their entry paid tier. Both ship a tab-completion model and a multi-file agent. Both wire in the same frontier models — GPT-5, Claude Opus, Gemini. Reviews that score them feature-by-feature end up in 47-43 ties because the feature lists genuinely match. That kind of comparison misses the point. The two editors feel different to use, and the difference matters more than the feature checklist. This piece tests both side-by-side across two weeks of normal client work — Python, TypeScript, Go — and lands on a clear verdict at the end about which one fits which kind of developer. Pricing and feature claims here were verified against Windsurf's pricing page and Cursor's pricing page on May 5, 2026. Both vendors change pricing more than most editors — re-verify before subscribing. Pricing: nearly identical The pricing tables converged in 2025 and have stayed mirrored since: Tier Cursor Windsurf Free Hobby (limited Agent + Tab) Free Entry paid Pro $20/mo Pro $20/mo Heavy individual Pro+ $60/mo (3× usage) / Ultra $200/mo (20× usage) Max $200/mo (heavy users, unlimited extra at API pricing) Team Teams $40/user/mo Teams $40/user/mo Enterprise Custom Custom Cursor offers a middle tier (Pro+ at $60) that Windsurf doesn't match exactly. Windsurf has a "Light" plan with unlimited usage on cheaper models that Cursor doesn't have. These are minor — for the typical individual developer choice, both are $20/month for Pro and $200/month for the power-user tier . The entry decision is therefore not a price decision. It's a workflow-fit decision. Both ship a standalone editor A common misconception: "Windsurf is a VS Code extension, Cursor is its own editor." Both are standalone applications. Both fork VS Code. Both can install most VS Code extensions from the Open VSX Registry (with occasional compatibility