This article walks through a real MMO project, showing step‑by‑step how to use the Cursor AI agent to accelerate development, from requirement analysis and task breakdown to code generation, review, testing, and workflow automation, while sharing practical prompts and Erlang code examples.
This article explains what streaming queries are, why MyBatis's Cursor requires an open database connection, and presents three practical solutions—using SqlSessionFactory, TransactionTemplate, or @Transactional—to correctly implement MyBatis streaming queries in Spring applications while avoiding common pitfalls.
This article outlines a practical, step‑by‑step approach for technical leaders and engineers to introduce the Cursor AI coding assistant into team workflows, covering motivation, common challenges, a structured R&D process, prompt design, rule creation, and detailed phases from requirement analysis to release.
This article explains why AI coding assistants often fall short, outlines three common pitfalls—imprecise prompts, misuse, and wrong tool choice—and demonstrates how the Cursor IDE can dramatically accelerate development through context‑aware code generation, autonomous task execution, and built‑in code review.
This article explains the Model Context Protocol (MCP), compares it with traditional function calling, and provides a step‑by‑step guide for integrating MCP into the Cursor editor, including token generation, configuration, server setup, and practical examples that dramatically improve AI‑assisted development productivity.
This article reviews the AI‑native code editor Cursor, compares its capabilities and limits to tools like Copilot, and details a full‑cycle case study where the author used Cursor to redesign a store‑decoration platform, highlighting design decisions, implementation steps, metrics, and lessons learned.
This article compares the AI programming assistants Roo Code and Cursor, detailing their features, prompt systems, specialized modes, tool integrations, API transparency, code interaction workflows, cost structures, and provides guidance on choosing the right tool for developers seeking precise context management and efficient coding assistance.
In this interview, Cursor CEO Michael Truell explains the company’s mission to revolutionize coding with AI, discusses the evolution of AI‑assisted development, shares insights on product strategy, scaling challenges, and the broader impact of intent‑driven programming on software engineering.
This article provides an in‑depth comparison of the AI‑powered coding assistants Cursor and Augment, examining their core features, code‑completion capabilities, context awareness, enterprise security, pricing models, and ideal user scenarios to help developers choose the best tool for their projects.
This guide walks you through using Cursor together with MCP to quickly create a full‑stack "What to Eat Today" wheel web app, covering environment setup, Supabase project configuration, database schema design, component development with Next.js, AI‑generated prompts, and deployment tips.
Anysphere's Cursor 1.0 launch introduces AI‑driven tools like BugBot, Background Agent, and Memories, while sparking debate over its VS Code fork strategy, competitive standing, revenue model, and emerging security concerns such as prompt‑injection attacks.
Cursor 1.0 introduces AI-driven BugBot for automatic PR reviews, a publicly available Background Agent for remote coding, a memory system that retains custom rules, and one‑click MCP installation with OAuth support, alongside enhanced chat visuals, Jupyter integration, and various UI and model improvements.
This article introduces DeepWiki MCP, explains its advantages, limitations, and integration steps with Cursor and Dify, and shows how its SSE and Streamable HTTP protocols enable accurate GitHub documentation access, improving AI‑driven code assistance while highlighting timeliness challenges.
Cursor 1.0 introduces AI-powered BugBot for automatic PR reviews, a universally available Background Agent for remote coding, a memory system for rule retention, one‑click MCP installations with OAuth support, plus numerous UI and performance enhancements, offering developers a more efficient, cloud‑centric workflow.
This article shares a step‑by‑step guide on planning, documenting, templating, configuring, and rule‑setting for the Cursor AI coding assistant, showing how thorough preparation transforms it from a source of buggy code into a reliable development partner.
This article walks through the Model Context Protocol (MCP) concepts, demonstrates how Cursor leverages Docs and Rules to develop a weather‑service MCP server in TypeScript, explores a gold‑price prediction project, and shares practical tips, advantages, and limitations of AI‑assisted coding.
Discover twelve practical techniques—from setting clear project rules and crafting precise prompts to modular development, test‑driven generation, context management, and model selection—that help developers maximize productivity and code quality when working with AI‑powered editors like Cursor, Windsurf, or CodeBuddy.
This guide outlines a systematic workflow for using the Cursor AI coding assistant—starting with precise requirement planning, creating project documentation, leveraging starter kits, injecting context files, configuring granular project rules, and finally achieving stable, maintainable code output.
This article walks through Amap's Model Context Protocol (MCP) service, explaining its purpose, installation steps, configuration in the Cursor client, and practical examples such as travel planning and location‑based queries, while also evaluating its strengths and current limitations.
The article introduces Cursor, an AI‑powered coding assistant, outlines its supported large models, demonstrates practical front‑end use cases such as automatic layout creation, button logic, screenshot‑to‑code generation, error fixing and code cleanup, and reflects on prompt engineering and tool selection.
This article walks through Cursor 0.49’s new auto‑generated Project Rules feature, explains its key updates, provides step‑by‑step instructions for creating rules from chat context, showcases real‑world tests on front‑end projects, and offers practical best‑practice recommendations and cautions for developers.
This guide explains how to obtain a token, install MasterGo MCP in Cursor, configure the mcp.json file, and use the provided getDSL and getComponentLink tools to retrieve design canvas DSL and generate front‑end code such as React, Vue, or Flutter components.
The article examines how Microsoft’s licensing restrictions have caused the VSCode C/C++ extension to stop working on the Cursor AI IDE, explores the underlying marketplace policies, the role of new AI features, and the community’s responses and workarounds.
This article walks through solving Cursor's inaccurate date handling by installing an MCP time server, creating a minimal FastMCP‑based MCP server in Python, configuring Cursor to use it, and demonstrating how to automate time‑stamped task tracking with practical code examples.
This guide shares a systematic, experience‑driven approach to leveraging Cursor’s AI capabilities—from project planning and codebase structuring to custom AI rules, Notepad management, version‑control integration, and advanced workflow automation—helping teams boost development speed while maintaining code quality.
The article evaluates Augment Code, an AI‑powered coding assistant with 200K token context, persistent memory, multimodal input, and top SWE‑bench scores, walks through its installation, explores its use on vllm and PagedAttention, demonstrates adding a new model and auto‑generating a WeChat mini‑program, and compares its capabilities and speed to Cursor.
This guide outlines practical project‑management practices and tool configurations—such as using Cursor rules, Notepad, milestone documents, and regular code‑base re‑indexing—to maximize the effectiveness of the Cursor AI assistant in large‑scale software projects.
This article walks Java developers through configuring the Cursor IDE, essential plugins, advanced JDK and Maven settings, AI-powered coding assistance, shortcut tips, and best‑practice workflows that together can increase daily development efficiency by roughly forty percent.
This guide walks you through setting up Cursor, an AI‑enhanced VS Code‑based editor, on macOS and configuring full development environments for Python, JavaScript/TypeScript, Swift, and Java, including essential tools, virtual environments, plugins, and VS Code settings to boost productivity.
The article explains how Vite’s native ES‑module architecture and the Model Context Protocol (MCP) enable deep AI integration via the vite‑plugin‑vue‑mcp, allowing tools like Cursor to access component trees, state and routing, which the author claims can raise development speed by up to 200% and cut bugs by 65%.
This tutorial explains how to set up and use the open‑source Figma MCP service with the Cursor AI IDE, covering API key creation, server configuration, command‑line startup, JSON setup, and a React ECharts example, plus troubleshooting tips for successful integration.
This article explains what the Model Context Protocol (MCP) is, lists popular MCP service marketplaces, and provides step‑by‑step instructions for adding global or project‑level MCP servers in Cursor, including JSON configuration, verification, usage examples, tips, and troubleshooting.
This guide walks through setting up the MCP protocol on macOS, configuring a server, installing Bun, linking Cursor 0.47+ with Figma, importing the plugin manifest, enabling MCP in Cursor, and using prompt templates to automatically generate high‑quality iOS fitness app designs, complete with screenshots and practical tips.
This article explains how the author leveraged the Cursor AI coding assistant to rapidly prototype a license‑approval workflow system, detailing the project background, required features, technology stack, Cursor’s yolo mode, step‑by‑step usage tips, code examples, and practical reflections on AI‑assisted development.
This guide demonstrates how to integrate the Cursor AI editor with Git to automate commit message generation, streamline branch management, perform intelligent code reviews, resolve merge conflicts, and generate commands, offering concrete prompts, shortcuts, and visual examples that enhance version‑control efficiency for development teams.
The article details how the author discovered a bug in Cursor’s closed‑source IDE where correctly registered MCP services, such as a weather query tool, are omitted from the LLM’s tool list, preventing calls, and explains the debugging steps that compared Cursor with the open‑source Cline implementation to pinpoint the registration flaw.
The article analyzes the technical, performance, and user‑experience hurdles of implementing efficient single‑project codebase indexing in AI‑driven IDEs, explaining why GitHub Copilot lags behind competitors like Cursor despite its strong AI foundation.
The article demonstrates how, with Cursor’s AI‑assisted coding and its YOLO mode, a developer can rapidly build a full‑stack license‑approval system—Vue 3 front‑end, Go/Gin back‑end, JWT authentication, MySQL storage—in under a day of effort, highlighting practical tips, limitations, and the broader potential for low‑code creation.
This article explains how Cursor Rules let developers constrain AI behavior in the Cursor editor, covering global and project rule types, practical file configurations, best‑practice examples for general, Python, documentation, and Git rules, and tips for effective rule management.
The author shares practical experiences and reflections on using AI tools like Cursor and Claude 3.7 to develop a web application, highlighting the growing importance of demand analysis, workflow integration, and the nuanced impact of AI on software engineering jobs.
This comprehensive technical guide explores how to leverage AI-powered coding assistants like Cursor to efficiently generate high-quality unit tests for modern frontend applications, detailing essential frameworks, structural patterns, and practical optimization techniques.
The author describes the problems of wasted storage, expired food, hard-to‑locate items, and duplicate purchases after moving house, then details an AI‑driven home inventory app built with Cursor, Trae, and large‑vision models that digitizes, classifies, and reminds about household goods, complete with architecture, implementation steps, and a comparative review of the AI tools used.
This guide explains what the .cursorrules file does, how to create and configure it in a project, best‑practice rules for specifying tech stacks, coding standards, libraries, file structures, performance and testing guidelines, and provides example configurations for frontend, backend, and data‑science stacks.
The article details a step‑by‑step workflow that uses two carefully crafted prompts with Cursor to automatically locate source files in a large monorepo, record tasks, iteratively generate Vitest unit tests, track progress, and handle failures, turning a 11 k‑line codebase into a semi‑automated test suite.
This article introduces Cursor’s AI‑driven Agent mode, details the latest updates, explains core functionalities, shows how to enable and use it, and provides seven advanced tips—including context management, code generation, version control, and custom AI rules—to boost developer productivity.
Trae, a new AI‑driven IDE, offers a dark‑theme interface, integrated Chat Builder Beta, version‑control cues, and Claude‑3‑Sonnet support, and while it mirrors many Cursor features such as smart completion and chat, it adds educational prompts and context‑enhanced inputs, though it still faces WSL compatibility and beta stability issues.
This article introduces DeepSeek, a high‑efficiency search engine optimized for large‑scale data, explains how to configure it within the Cursor database tool using code snippets, and demonstrates its applications such as semantic search, content recommendation, intelligent data analysis, and document similarity matching.
This article compares the new AI‑integrated Cursor editor with the established Visual Studio Code, examining core features, AI code generation, workflow simplification, ecosystem compatibility, and target developer scenarios, ultimately assessing whether Cursor can realistically supplant VS Code for various programming needs.
The article conducts a practical, step‑by‑step evaluation of Cursor, Windsurf, and GitHub Copilot’s multi‑file editing capabilities using a simple web‑chat bot, revealing that Cursor completes all required UI, storage, and application changes in a single interaction, while the others need two rounds, with Copilot showing notable improvement on a retest.
When processing massive MySQL result sets, loading all rows into JVM memory can cause OOM and slow performance, so this guide compares three approaches—regular pagination, streaming queries using server-side cursors, and cursor‑based fetchSize control—detailing their implementations, MyBatis configurations, and trade‑offs.
This article walks through how the author leveraged GPT, Cursor, and carefully crafted prompts to automatically generate a fully functional TikTok‑style front‑end, from initial design screenshots to deployment on Vercel, all without manually writing any code.
This article surveys the leading AI‑powered code editors—including GitHub Copilot, Cursor, CodeGeeX and others—detailing their pricing, core features such as code completion, inline and sidebar chat, project‑wide editing, and step‑by‑step setup instructions for developers of any skill level.
This article walks through how to enable voice-driven coding with GitHub Copilot, VS Code Speech, and Cursor, detailing plugin installation, configuration steps, shortcut keys, and tips for using system or input‑method speech input to create a seamless hands‑free AI coding experience.
This article presents four actionable techniques—clearly stating requirements, requesting code comments, invoking the Composer with Command/Ctrl + I, and configuring AI rules in Settings—to help developers maximize productivity when working with the Cursor AI coding assistant.
This guide shows how to create a Cursor‑style AI‑native IDE by forking the open‑source CodeFuse project built on the extensible OpenSumi framework, configuring a large‑language model, and packaging an Electron app, while explaining Cursor’s advantages over plugin‑based tools and the strategic benefits of a fully integrated AI development environment.
This article provides a comprehensive guide to MySQL stored procedures, functions, custom functions, variables, control‑flow statements, cursors, and condition/handler definitions, illustrating creation, invocation, inspection, modification, and deletion with concrete SQL examples.
This article explains why using OFFSET and LIMIT for pagination becomes inefficient on large tables, illustrates the performance impact with examples, and proposes a cursor‑based pagination alternative that leverages indexed primary keys to achieve faster, scalable queries.
This article explains why using OFFSET with LIMIT becomes a performance bottleneck on massive tables, demonstrates the inefficiency of full‑table scans, and introduces a faster cursor‑based pagination technique that leverages indexed primary keys for efficient data retrieval.
This article explains how OFFSET and LIMIT cause severe performance problems on large tables due to full‑table scans, demonstrates the issue with real‑world examples, and presents a more efficient cursor‑based (keyset) pagination technique as a practical alternative.
This article explains why using OFFSET and LIMIT for pagination becomes a performance bottleneck on massive tables, illustrates the cost of full‑table scans, and introduces a cursor‑based pagination technique that leverages primary‑key ordering for efficient data retrieval.
This article explains why using OFFSET and LIMIT for pagination on large tables leads to costly full‑table scans and poor performance, and introduces keyset (cursor) pagination as a faster, index‑driven alternative while discussing its requirements and trade‑offs.
This article introduces AI‑powered tools Copilot and Cursor, explains their capabilities such as code completion, diagram generation, refactoring, SQL optimization, batch processing, and unit‑test creation, and provides practical best‑practice tips, shortcut keys, and efficiency analysis for each stage of software development.
This article explains how to use MyBatis streaming queries via the Cursor interface, showing configuration, code examples, batch processing techniques, practical use cases, and important precautions to efficiently handle large result sets without exhausting JVM memory.
This article explains MyBatis streaming queries, introduces the Cursor interface and its key methods, shows how to implement streaming with code examples, discusses suitable application scenarios, and outlines important considerations for efficient, low‑memory data processing in Java backend systems.
This article introduces MyBatis streaming query using the Cursor interface, explains its core methods, demonstrates implementation with code examples, discusses suitable application scenarios, and outlines important considerations for efficient and safe large‑scale data processing in Java backend development.
This article introduces MyBatis streaming queries, explains the Cursor interface and its methods, provides step‑by‑step code examples for configuration and implementation, discusses practical application scenarios such as large‑scale data processing, and highlights important considerations for efficient and safe usage.
The article explains the performance drawbacks of using OFFSET and LIMIT for pagination on large tables, illustrates the issue with full‑table scans, and presents a more efficient cursor‑based approach that leverages indexed primary keys to retrieve pages quickly.
Cursor is a free, open‑source AI coding editor built on ChatGPT‑3 that supports multiple languages, offers features like code generation, diff comparison, chat‑style assistance, lint fixing, and aims to become a highly efficient development environment through future AI‑driven enhancements.
The article explains how to efficiently retrieve and process massive MySQL result sets in Java using MyBatis, comparing regular pagination, streaming queries via Cursor, and cursor-based fetchSize techniques, and provides practical code examples and best‑practice tips to avoid OOM and improve performance.
The article explains how to process massive MySQL data sets—covering data migration, export, and batch handling—by comparing regular pagination, streaming queries using server‑side cursors, and cursor‑based fetchSize techniques, and provides concrete MyBatis code examples for each approach.
To efficiently process massive MySQL result sets without exhausting JVM memory, this article explains three query strategies—regular pagination, stream-based retrieval using MyBatis cursors, and cursor-based fetching with configurable fetchSize—detailing their implementations, advantages, and practical considerations.
Processing massive datasets in MySQL can cause OOM and slow performance; this article explains when to use regular pagination, streaming queries, and cursor-based fetching, compares their trade‑offs, and provides MyBatis code examples with @Options and @ResultType to handle millions of rows efficiently.
This article explains why using OFFSET and LIMIT for pagination becomes inefficient as data grows, leading to costly full table scans, and demonstrates a high‑performance cursor‑based pagination alternative that leverages indexed primary keys to retrieve pages quickly and reliably.
The article explains the performance problems of using OFFSET and LIMIT for large‑scale database pagination, demonstrates their inefficiency with full‑table scans, and presents a faster cursor‑based alternative that relies on storing the last primary key and using LIMIT instead of OFFSET.
The article details how the Xianyu team built a feature‑complete, extensible, high‑performance Flutter rich‑text editor called Mural by defining a Slate‑inspired protocol layer, mapping it to a custom widget/render object tree, handling cursor and WidgetSpan selection, using diff‑based updates, and providing a plug‑in architecture for extensions.
This article explains the concept of streaming queries, introduces MyBatis's Cursor interface with its key methods, and provides three practical solutions—using SqlSessionFactory, TransactionTemplate, or @Transactional—to keep database connections open and avoid cursor‑closed errors in Spring MVC applications.
Streaming queries return an iterator instead of a full result set, reducing memory usage, but require the database connection to stay open; this guide explains MyBatis’s Cursor interface, its methods, common pitfalls like premature closure, and three practical solutions using SqlSessionFactory, TransactionTemplate, or @Transactional to ensure reliable streaming.
This article explains what streaming queries are, why they save memory compared to pagination, details the MyBatis Cursor interface and its methods, demonstrates how to implement streaming queries with code examples, and presents three solutions—using SqlSessionFactory, TransactionTemplate, and @Transactional—to keep the database connection open and prevent cursor‑closed errors.
This article explains how MyBatis streaming queries work via the Cursor interface, why keeping the database connection open is essential, and presents three practical solutions—using SqlSessionFactory, TransactionTemplate, or @Transactional—to correctly handle streaming data in Spring applications.
This comprehensive tutorial explains how selections and cursors work in web pages, covering the underlying Selection and Range APIs, handling editable and non‑editable elements, manipulating text in inputs, textareas, and rich content, and providing practical code snippets for every scenario.
This article explains how Apache Pulsar brokers track consumer acknowledgments using cursors, store metadata in ZooKeeper and BookKeeper, handle acknowledgment gaps with range sets, and optimize memory usage through LRU and segmented storage to ensure reliable message delivery.
This article explains the concept of streaming queries in MyBatis, introduces the Cursor interface, demonstrates typical usage with try‑resource, and provides three practical solutions—using SqlSessionFactory, TransactionTemplate, and @Transactional—to keep the database connection open and avoid cursor‑closed errors.
The article explains the concept of streaming queries in MyBatis, introduces the Cursor interface, demonstrates how to use it in Spring MVC controllers, and provides three practical solutions—SqlSessionFactory, TransactionTemplate, and @Transactional—to keep the database connection open during iteration.
This article explains the concept of streaming queries, introduces MyBatis' Cursor interface, demonstrates how to use it in Spring MVC controllers, and provides three practical solutions—using SqlSessionFactory, TransactionTemplate, or the @Transactional annotation—to keep the database connection alive during iteration.
Streaming queries return an iterator instead of a full result set, reducing memory usage, but require keeping the database connection open; this guide explains MyBatis’s Cursor interface, its methods, and three practical ways—using SqlSessionFactory, TransactionTemplate, or @Transactional—to safely perform MyBatis streaming queries in Spring.
This article explains the concept of MyBatis streaming queries, why keeping the database connection open is essential, and provides three concrete approaches—using SqlSessionFactory, TransactionTemplate, or @Transactional—to ensure cursors remain usable without premature closure.
This article explains the concept of streaming queries, introduces MyBatis's Cursor interface, demonstrates common pitfalls such as closed cursors, and provides three practical solutions—using SqlSessionFactory, TransactionTemplate, or @Transactional—to keep database connections open while processing large result sets.
This article explains MyBatis streaming queries using the Cursor interface, demonstrates how to define a Mapper that returns a Cursor, shows common pitfalls with closed connections, and provides three solutions—manual SqlSession handling, TransactionTemplate, and @Transactional—to keep the database connection open while iterating results.
This article explains what a streaming query is, introduces MyBatis's Cursor interface and its methods, demonstrates common pitfalls such as the cursor being closed prematurely, and provides three practical solutions using SqlSessionFactory, TransactionTemplate, and @Transactional to keep the database connection alive during streaming reads.
This article explains the concept of streaming queries in MyBatis, describes the Cursor interface and its methods, demonstrates common pitfalls that cause cursor closure errors, and provides three practical solutions—using SqlSessionFactory, TransactionTemplate, or @Transactional—to keep the database connection open during iteration.
This article explains the challenges of returning large result sets in APIs, compares traditional offset‑based pagination with cursor‑based approaches, shows performance differences through SQL examples, and discusses why cursor pagination is more efficient for deep paging and concurrent data modifications.
This article explains the concept of streaming queries, introduces MyBatis's Cursor interface, demonstrates how to use it in Spring MVC controllers, and provides three concrete solutions—using SqlSessionFactory, TransactionTemplate, and @Transactional—to keep the database connection open and avoid cursor‑closed errors.
This article explains the concept of streaming queries, introduces MyBatis's Cursor interface, demonstrates common pitfalls with closed connections, and provides three practical solutions—using SqlSessionFactory, TransactionTemplate, or @Transactional—to safely perform large‑scale data retrieval in Spring applications.
This article explains the concept of streaming queries, introduces MyBatis's Cursor interface, demonstrates common pitfalls when the database connection closes prematurely, and provides three practical solutions—using SqlSessionFactory, TransactionTemplate, or @Transactional—to keep the connection open for efficient data retrieval.
This article explains the concept of streaming queries in MyBatis, introduces the Cursor interface, demonstrates common pitfalls with connection closure, and provides three practical solutions—using SqlSessionFactory, TransactionTemplate, or @Transactional—to safely retrieve large result sets without exhausting memory.
The article explains the performance problems of using OFFSET and LIMIT for database pagination on large tables, demonstrates their inefficiency with real‑world examples, and presents cursor‑based pagination as a high‑performance alternative that leverages indexed primary keys.
The article explains why using the KEYS command on large Redis datasets can cause service blockage and demonstrates how the SCAN command with MATCH and COUNT options provides a non‑blocking, incremental way to list keys, including syntax and practical examples.
This article explains Oracle cursor concepts, the key V$SQL and V$SQLAREA views with their most important columns for tuning, how open‑cursor limits and the CURSOR_SHARING parameter affect execution plan sharing, and provides practical guidance for DBA performance optimization.
This article explains Oracle cursor concepts, details the key V$SQL and related views, highlights crucial columns for performance tuning, and describes important parameters such as open_cursor and cursor_sharing, helping DBAs optimize SQL execution and manage shared pool memory effectively.
