Cursor guides and products

Cursor's coding assistant can read and edit files, search a codebase, run commands, and use a browser. Rules provide reusable instructions, while external tool connections bring other services and data into coding sessions.

Source: Cursor

Products and platforms

Cursor

Integration guides

Connect Cursor to your fenbs kanban board

All Cursor articles

How to connect fal MCP to Claude Code or CursorConnect fal’s official generation server with browser sign-in, check model discovery, and save your instructions and accepted results for another session.2026-10-26 · 4 min read
DeepSeek in Cursor: check the provider before setupA compatible API address does not prove native Cursor support. Here is how to verify the DeepSeek route, protect the key and test the intended model.2026-10-23 · 5 min read
Cursor worktrees: keep parallel changes separatePrepare separate Git working folders for independent Cursor tasks, give each one a clear owner, and preserve the checks needed for a safe handoff.2026-10-22 · 5 min read
Cursor Rules for Database Work: Schema, Queries, and ChangesCursor rules for database work tell the assistant which schema changes require review, which query patterns are approved, and how to handle migrations and changes safely. Keep the decisions and approvals the rules refer to in fenbs.2026-10-21 · 4 min read
Cursor Rules for Bash: Safer Shell Instructions to ReuseHow to write scoped Cursor rules for Bash scripts that require proper quoting, path checking, and command review, with a clear line between instructions and enforcement, and fenbs keeping the agreed rules and project exceptions.2026-10-18 · 4 min read
Cursor Rules for Java Spring Boot: Examples You Can AdaptScoped Cursor rules for Spring Boot projects: architecture, configuration, tests, and dependency choices, with fenbs keeping the project decisions and review work outside reusable rule files.2026-10-15 · 5 min read
Llama in Cursor: verify a gateway chat setupCheck the model host, credentials, and client requirements before trying Llama through a gateway in Cursor. Test chat and coding actions separately.2026-10-15 · 5 min read
Windsurf and Cursor Rules: How to Move Your InstructionsMove the meaning of your project rules, then check when they apply. Translate the editor settings while keeping approved decisions and unfinished work available outside either editor.2026-10-08 · 5 min read
Are Cursor Rules Deprecated? Legacy Files and MigrationCursor has moved from a single .cursorrules file to a .cursor/rules/ directory with individual rule files. Learn which formats are still supported, how to migrate legacy rule files, and how to keep the underlying project decisions intact during the move.2026-10-07 · 6 min read
Cursor Rules and Hooks: Instructions vs. Executed ChecksCursor rules tell the assistant what to do; hooks execute verification commands automatically. This guide explains the difference, where each one fits, and how fenbs holds the approved workflow decisions both should reflect.2026-10-06 · 5 min read
Cursor Rules Length: Keep Requirements, Cut RepetitionShorter Cursor rules are useful when they preserve the instructions that matter. Separate maintenance recommendations from hard limits, then measure context use and test behavior before cutting more.2026-10-06 · 6 min read
Import Cursor Rules: Reuse Files Without Copying MistakesHow to import rule files from another project or a shared library, adapt their scope, and verify that their assumptions still hold, with fenbs retaining the approved source templates and project-specific decisions that override them.2026-10-03 · 5 min read
Cursor Rules for Terraform: Plans, State, and ReviewsCursor rules for Terraform that cover environment separation, state file handling, plan review steps, and approval boundaries, with fenbs keeping the human decisions and change rationale the rules point to.2026-10-02 · 4 min read
Cursor vs VS Code With Copilot: What You Gain by SwitchingCursor is built on the VS Code codebase, so switching changes the AI layer, the extension registry and the plan you pay through, not the editor under your hands. A side-by-side on agent modes, rules files, MCP, models and plans, from each vendor’s own docs.2026-10-01 · 7 min read
Zed and Cursor Rules: Move Your Project InstructionsHow to translate Cursor project rules into the formats Zed supports, what carries over and what does not, and how fenbs keeps shared project decisions outside either editor so switching is not a rebuild.2026-10-01 · 4 min read
What Is Cursor AI? The Editor, Its Agent and Who It SuitsCursor is a code editor built on the VS Code codebase with an AI agent at its center. What the editor, Tab and the agent do, which models it runs, how rules and MCP work, where the CLI and cloud agents fit, the plans by name, and who it suits better than a terminal agent.2026-09-30 · 7 min read
Cursor Usage Limits and Pricing Model Explained, Without PricesCursor’s plans include a monthly usage budget, split into a pool for Cursor’s own models and a pool for third-party models billed at their API rates. How usage is counted, what Auto and your own API key do to it, what happens at the limit, and how it compares with Claude Code’s windows.2026-09-30 · 7 min read
Claude Code vs Cursor vs GitHub Copilot: Picking One for a TeamFor one developer the choice is about taste. For a team it is about what an admin can enforce, what you can see afterward, where code goes, and whether everyone can share one setup. The three side by side on those questions, with links to the head-to-head comparisons.2026-09-30 · 8 min read
Cursor Alternatives: AI Editors ComparedThe editors people pick instead of Cursor, sorted by the reason you would switch: staying in VS Code, a faster native editor, a JetBrains IDE, a spec-first workflow, or a command center for many agents. What each one is today, and what to carry over when you move.2026-09-29 · 7 min read
Context Engineering in Cursor: What Its Agent Sees, and How to Change ItCursor fills its agent’s context window from rules, @-mentions, its own search, skills, subagents and MCP servers. Here is what each one costs, what it keeps out, and where each kind of information belongs.2026-09-28 · 8 min read
Claude Code vs Cursor: Which Fits the Way You WorkOne is an agent that started in the terminal, the other an editor built around its agent. Where each runs, how each plans, which instruction files each reads, how you approve and undo its work, and who each suits.2026-09-28 · 8 min read
Google Antigravity vs Claude Code, and Where Cursor FitsAntigravity is Google’s agent-first platform: a desktop command center for many agents, a terminal client, an IDE and editor extensions, with plans, walkthroughs and browser recordings you review as artifacts. Claude Code is Anthropic’s agent, one engine in a terminal, editors, a desktop app and the web. How they differ on models, parallel agents, review and where the work is recorded, with Cursor in brief.2026-09-28 · 8 min read
Cursor vs Codex: Editor Agent or OpenAI’s Coding AgentCursor is an editor built around its agent, with a CLI and cloud agents. OpenAI Codex is one agent with a CLI, an IDE extension, a view in the ChatGPT desktop app and a cloud. How they compare on instruction files, approvals and sandboxing, pull request review and models, why you can run Codex inside Cursor, and who each suits.2026-09-28 · 6 min read
Cursor Cloud Agents (Formerly Background Agents): Setup, Limits and ReviewCursor’s background agents are now called cloud agents. How to set up the environment they run in, keep secrets out of the transcript, start one from the editor, Slack, GitHub or the terminal, watch it work, and review what it hands back.2026-09-28 · 8 min read
Cursor Agent vs Ask vs Plan Mode: Which to Use WhenCursor’s agent has four built-in modes: Agent changes things, Ask answers, Plan proposes, and Debug investigates. Choose by how big the task is and what a wrong first attempt would cost, and know what happens to the context when you switch.2026-09-28 · 7 min read
Cursor Rules Examples: .mdc Files for Five StacksFive annotated Cursor rule files, for a Next.js app, a Python API, a monorepo package, writing tests and writing docs, each with the frontmatter for its rule type, plus when a plain AGENTS.md is the better choice and the lines that never belong in a rule.2026-09-28 · 8 min read
Cursor CLI: Using Cursor’s Agent From the TerminalCursor’s agent also runs in a terminal, as a command called agent. How to install it and sign in, the interactive and print modes, models, rules and AGENTS.md, MCP, permissions, the output formats scripts read, and running it in CI.2026-09-28 · 7 min read
ClickUp MCP in Cursor and VS CodeConnect ClickUp’s official MCP server to Cursor, VS Code and Codex: the one URL, the browser sign-in, where each editor keeps the entry, and how to stop any of them changing ClickUp without asking.2026-09-28 · 7 min read
Trello MCP in Cursor and VS CodeConnect Trello’s official MCP server to Cursor, VS Code and Codex: the one-click install, the mcp.json and config.toml entries, the workspace you choose at sign-in, and how to let reads run while every change still asks.2026-09-28 · 6 min read
Cursor Agent Not Working: Fixes for Stuck and Failed RunsA Cursor agent that times out, sits on a terminal command, stops at a usage limit or cannot see your files is usually telling you which of eight things went wrong. How to read the symptom, the fix Cursor documents for each, and what to send support when none of them works.2026-09-28 · 7 min read
How to Use the Jira MCP Server in CursorConnect Cursor to Jira through the Atlassian Rovo MCP Server: the one-click plugin or an mcp.json entry, the OAuth sign-in and what to do when an admin blocks it, which tools to let run without asking, and token access for machines without a browser.2026-09-27 · 6 min read
Cursor Rules for AI Projects: Keep the Agent on the TaskProject rules in .cursor/rules tell Cursor’s agent how your codebase works. Written well, they also keep it on one task: which task it is, what it may touch, and where it reports what it did. The four rule types, what they do not cover, and a board rule you can copy.2026-09-27 · 7 min read
How to Use Linear MCP in CursorConnect Cursor’s agent to Linear through Linear’s hosted MCP server: the one-click install or an mcp.json entry, the browser sign-in, a read-only connection, which tools to allowlist, and how it differs from Cursor’s own Linear integration.2026-09-27 · 6 min read
Using the Asana MCP Server in CursorAsana’s MCP server needs a registered app before Cursor can sign in. The four steps that get you connected, what to ask first in Agent chat, and how to keep Cursor from changing Asana without asking.2026-09-27 · 6 min read
Cursor With the GitHub MCP ServerHow to add GitHub’s official MCP server to Cursor: the hosted server with a token read from your environment, or the local one with a browser sign-in; a read-only entry beside a read-write one; and what to ask first.2026-09-27 · 6 min read
GitHub Copilot Agent vs Cursor Agent: Handling Multi-Step TasksBoth agents plan, edit, run commands and keep going until a task is done. The differences are in the structure around that loop: how each plans, asks before acting, lets you undo, hands work to the cloud and reads your rules.2026-09-27 · 8 min read
Cursor Rules for TypeScript: Types, Boundaries, and ChecksPractical Cursor rules for TypeScript that enforce strictness settings, public type placement, package boundaries, and verification commands, with fenbs keeping the approved API decisions that shape those constraints.2026-09-27 · 4 min read
Cursor Rules for Java: Builds, Frameworks, and TestsJava projects differ significantly by build tool and framework. These Cursor rules templates cover Maven and Gradle projects with Spring Boot and Quarkus adaptations, and the role fenbs plays in keeping chosen conventions shared.2026-09-26 · 5 min read
Cursor Rules Builder: Turn Project Standards Into Useful RulesDrafting a good Cursor rule means starting from a real project decision, not from a list of best practices. Learn how to extract, write, and review focused rules from your actual codebase, and how to keep them in fenbs where your team can improve them over time.2026-09-23 · 6 min read
How to Start Working With Cursor AIInstall Cursor, open the right repository, give the assistant a bounded task, and review a first change. Keep the project decisions available for the next session.2026-09-23 · 5 min read
Cursor Rules for Tailwind: Tokens, Layouts, and AccessibilityCursor rules for Tailwind CSS that cover design token usage, responsive layout patterns, reusable component classes, and accessibility checks, with fenbs preserving the design decisions assistants should apply consistently.2026-09-20 · 4 min read
Cursor Rules for .NET: C#, Project Boundaries, and TestsA practical rule set for .NET and C# projects in Cursor, covering solution structure, dependency direction, database conventions, and test commands. Adapt each rule to your project and keep the team decisions that make them specific in fenbs.2026-09-12 · 6 min read
Cursor System Prompt: What You Can Read and CustomizeCursor reads project rules files rather than a traditional system prompt. Here is what you can set, what the editor controls, and why treating leaked prompts as configuration is a mistake.2026-09-08 · 5 min read
Kiro and Cursor Rules: Move Instructions Between EditorsKiro and Cursor both use file-based instruction documents to guide their AI, but the formats, locations, and scope mechanisms differ. Here is how to translate project guidance between them, and what belongs in neither.2026-09-07 · 7 min read
Cursor Rules for Flutter: Widgets, State, and TestsA practical rule set for Flutter projects in Cursor, covering widget structure, state management, platform boundaries, and verification commands. Adapt each template to your project and keep shared product context and technical decisions in fenbs.2026-09-06 · 6 min read
Cursor Rules for Nuxt: Rendering, Data, and ComponentsNuxt projects involve clear decisions about rendering modes, data fetching composables, component conventions, and how server and client code is separated. These Cursor rules capture what an AI assistant needs to follow those decisions consistently.2026-09-05 · 5 min read
Cursor Rules for Clean Architecture: Boundaries, Modules, and ChecksAdaptable Cursor rules for clean architecture projects: dependency direction, module responsibilities, interface rules, and architecture checks, with fenbs preserving the reasons and exceptions behind them.2026-09-03 · 4 min read
Cursor Rules for a PRD: Keep Requirements in ContextHow to reference a product requirements document in Cursor rules without duplicating it in every rule file, and how fenbs keeps the accepted decisions, tasks, and scope changes.2026-08-31 · 4 min read
Cursor IDE Memory: What Persists Between Sessions?Cursor memory can mean saved instructions, project files, conversation context, or your computer’s RAM. Separate them so the right information survives your next session.2026-08-29 · 5 min read
Cursor Rules for Rust: Ownership, Errors, and TestsPractical Cursor rules for Rust covering crate boundaries, error type conventions, unsafe code review, and verification commands, with fenbs retaining the design decisions that generic Rust guidance cannot supply.2026-08-25 · 4 min read
Cursor Agent Memory: Keep the Next Session on TrackGive Cursor Agent reviewed instructions and a clear handoff, then test what a fresh conversation can recover before letting it continue the work.2026-08-24 · 5 min read
Cursor Rules for Git: Commits, Branches, and ReviewsGit workflow rules for Cursor tell the AI what commit format to follow, which branches it may create, and what it must not push. Here is a ready-to-use template and the decisions that belong alongside it in fenbs.2026-08-23 · 5 min read
Cursor Rules for MCP: Give Tool Use a Clear PurposeMCP (Model Context Protocol) lets Cursor connect to outside tools. Rules about which tools to discover, when to read project context first, and how to report tool-driven changes make that connection predictable and reviewable.2026-08-23 · 6 min read
Cursor Rules for Kotlin: Coroutines, Modules, and TestsKotlin projects need rules about coroutine ownership, Gradle commands, and how multiplatform source sets are divided. Here is a template that covers the most important conventions and the decisions that belong alongside them in fenbs.2026-08-22 · 5 min read
Cursor Rules for C#: A Project TemplateA ready-to-copy Cursor rules template for C# projects, covering build commands, naming conventions, nullable types, and review steps, with notes on keeping shared decisions in fenbs.2026-08-20 · 6 min read
Cursor Rules for Ruby on Rails: Models, Jobs, and TestsPractical Cursor rules for Rails projects: application boundaries, migrations, background jobs, and testing, with fenbs recording the domain decisions and recurring lessons behind those rules.2026-08-19 · 4 min read
Cursor Rules for Zustand: Stores, Selectors, and PersistenceA practical Cursor rules template for Zustand projects: store ownership, selectors, persistence, and tests, with fenbs preserving the state-management decisions your assistant needs before changing a store.2026-08-14 · 4 min read
Cursor Rules for PHP: Types, Dependencies, and TestsPHP projects without a framework still need rules about the runtime version, Composer commands, type declarations, and how tests are run. These Cursor rules capture the project-specific conventions an AI assistant needs without assuming a framework.2026-08-13 · 6 min read
Cursor Rules for NestJS: Modules, Validation, and TestsNestJS has strong conventions about module boundaries, dependency injection, validation with class-validator, and testing with Jest. These Cursor rules template captures what an AI assistant needs to follow them consistently.2026-08-12 · 6 min read
Cursor Rules for WordPress: Themes, Plugins, and ChangesCursor rules for WordPress that cover plugin and theme boundaries, output escaping, hook and filter usage, and verification steps, with fenbs retaining the client decisions and approved scope of each change.2026-08-12 · 4 min read
ChatGPT Canvas vs Cursor: Which Fits Your Coding Task?Canvas is a chat-based code editor for a single snippet. Cursor is a full IDE with AI built in, designed for working on an entire project. The right choice depends on the scope of your task.2026-08-11 · 7 min read
Cursor Rules for DevOps: Environments, Reviews, and ChangesCursor rules for DevOps work tell the assistant which environment changes require review, which tools are approved, and how to handle infrastructure safely. Keep the human-approved operational decisions each assistant must read in fenbs.2026-08-08 · 4 min read
Cursor Rules for Django: Models, Views, and TestsA practical rule set for Django projects in Cursor, covering ORM boundaries, migrations, settings management, and test commands. Adapt each template to your project and keep the decisions and recurring lessons that make them specific in fenbs.2026-08-08 · 4 min read
Cursor Rules for Angular ProjectsA practical rule set for Angular development in Cursor, covering module structure, change detection, reactive patterns, and verification commands. Adapt the templates to your project and keep team decisions consistent across assistants with fenbs.2026-08-05 · 4 min read
How to Use Cursor Rules in GitHub CopilotMove the useful content of your Cursor rules into instruction files Copilot supports. Translate when each rule applies, then check that it loads for the right task.2026-08-05 · 5 min read
Cursor Rules for TDD: Keep the Red, Green, Refactor LoopCursor rules that hold the assistant to the TDD cycle: write a failing test, make it pass with minimal code, then refactor. fenbs stores the task acceptance criteria and the lessons from failed attempts.2026-08-05 · 4 min read
Cursor Rules for Vue: Components, State, and TestsCursor rules for Vue that cover component API conventions, reactivity patterns, state ownership, and test requirements, with fenbs keeping the product decisions and naming conventions that should survive a model change.2026-08-05 · 4 min read
Cursor Rules Hierarchy: Scope, Precedence, and ConflictsCursor loads rules at different scopes — global, project, and subdirectory — and resolves conflicts when two rules apply to the same file. Learn how the hierarchy works and how to keep the decisions behind it in one place.2026-08-04 · 6 min read
Cursor Rules for Android and Kotlin ProjectsA practical rule set for Android and Kotlin development in Cursor, covering lifecycle behavior, architecture patterns, and verification steps. Adapt each template to your project and keep accepted project decisions in fenbs.2026-08-02 · 6 min read
Cursor Global Rules: Set Defaults Across Every ProjectCursor lets you write rules that apply to all your projects, not just one repository. Here is how to use global rules well and what belongs there versus in the project.2026-07-31 · 6 min read
Cursor Rules in Codex: Translate and Check Their ScopeMove useful Cursor instructions into AGENTS.md, preserve the boundaries around each rule, and check what Codex actually reads before starting work.2026-07-31 · 5 min read
Can You Use a ChatGPT Subscription in Cursor?A ChatGPT subscription and Cursor are billed separately. Here is why, what Cursor includes in its own AI plans, and how to keep your project context when you move between coding assistants.2026-07-29 · 6 min read
Cursor MCP Memory Bank: Keep Context Between SessionsBuild a useful project memory in Cursor by separating reference files, operating rules, and storage reached through MCP. Then test whether a fresh session can actually continue the work.2026-07-29 · 6 min read
Cursor Rules for JavaScript: Modules, Dependencies, and TestsJavaScript projects have strong opinions about module format, package scripts, and how dependencies are managed. These Cursor rules templates capture the conventions that stop an AI assistant from making well-intentioned but wrong choices.2026-07-23 · 5 min read
Cursor Rules Not Working: Check Scope, Format, and LoadingA step-by-step guide to diagnosing ignored Cursor rules: file format, activation settings, scope, and conflicting instructions, with fenbs keeping the verified fix for the next session.2026-07-23 · 4 min read
Cursor Rules for Code Review: A Practical TemplatePractical Cursor rules for AI-assisted code review: defect priority, evidence requirements, and project conventions, with fenbs keeping approved review criteria and recurring lessons.2026-07-22 · 4 min read
Cursor Rules for Backend Development: Data Access, Validation, and APIsAdaptable Cursor rules for backend projects: data access patterns, validation, interface design, and testing, with fenbs retaining accepted design decisions and exceptions shared across coding assistants.2026-07-20 · 4 min read
Cursor Rules for React Native and Expo ProjectsA practical Cursor rules template for React Native and Expo: platform-specific code, navigation, permissions, and device checks, with fenbs holding shared mobile decisions and the current handoff.2026-07-15 · 4 min read
Cursor Rules for LangGraph and LangChain ProjectsLangGraph and LangChain projects need rules about graph state ownership, tool boundaries, retrieval conventions, and how to run evaluation tests. These Cursor rules capture the conventions, and fenbs keeps the design decisions and lessons from earlier experiments.2026-07-14 · 6 min read
Cursor Rules Globs: Match the Files You MeanGlob patterns in Cursor rules control which files each instruction applies to. Learn the syntax, the most useful patterns for common project layouts, and how to avoid instructions reaching files they should not.2026-07-13 · 4 min read
Cursor Rules for Node.js: Runtime, Packages, and TestsNode.js projects need rules about which runtime version they support, how packages are managed, how async code is written, and which test commands to run. These Cursor rules templates keep an AI assistant aligned with your project's operational reality.2026-07-13 · 6 min read
Cursor Rules for Go: Packages, Errors, and TestsA practical rule set for Go projects in Cursor, covering package boundaries, error handling, concurrency patterns, and test commands. Adapt each template to your project and record the team decisions that make them specific in fenbs.2026-07-12 · 4 min read
Cursor Rules for iOS: Swift, Xcode Projects, and TestsA practical rule set for iOS and Swift projects in Cursor, covering app structure, Xcode project changes, platform API usage, and test commands. Adapt each template to your project and keep the product decisions that make them specific in fenbs.2026-07-09 · 4 min read
Cursor Rules for Bun: A Practical Project TemplateA ready-to-copy Cursor rules template for Bun projects, covering runtime commands, TypeScript conventions, and testing steps, with notes on keeping shared decisions in fenbs.2026-07-03 · 6 min read
Cursor Rules for Playwright: Stable Browser TestsA ready-to-paste set of Cursor rules for Playwright that keeps your tests reliable: stable locators, shared fixtures, proper assertions, and verification steps, with fenbs storing lessons from real failures.2026-06-29 · 4 min read
Cursor Rules Library: Find and Adapt Useful ExamplesPublic Cursor rule collections are a useful starting point, but most rules need project-specific changes before they are genuinely helpful. Learn how to find good examples, evaluate them, and build a library your team can reuse and improve.2026-06-27 · 6 min read
Cursor Rules for Unity: Scenes, Assets, and C# ScriptsCursor rules for Unity that cover scene and asset management, C# script conventions, playtesting requirements, and how fenbs retains gameplay decisions and current work status across assistant sessions.2026-06-27 · 4 min read
Cursor Rules for Godot: Scenes, Scripts, and Project ContextGodot projects have specific conventions around scene ownership, GDScript versus C#, resource changes, and playtest steps. These Cursor rules keep an AI assistant aligned with how your game actually works.2026-06-23 · 6 min read
Cursor chat history: find a conversation and resume workSearch earlier Cursor conversations, find the important part of a long transcript, and check what you can share. Then leave a short record of the next step.2026-06-20 · 5 min read
Cursor Rules for Kubernetes: Manifests, Contexts, and ReviewsPractical Cursor rules for Kubernetes manifest conventions, cluster context, secret handling, and change reviews, with fenbs recording the operational decisions behind them.2026-06-20 · 4 min read
Cursor Rules for Laravel: Eloquent, Routes, and TestsLaravel has strong conventions for Eloquent models, request validation, migration safety, and Artisan test commands. These Cursor rules capture what an AI assistant needs to follow them without guessing.2026-06-19 · 5 min read
Cursor Rules vs Commands: What Runs WhenCursor rules set standing instructions that apply to every session; commands are procedures you invoke for a specific task. Understanding the difference helps you put each kind of instruction in the right place and keep both effective. fenbs stores the reusable procedures and decisions both rely on.2026-06-18 · 7 min read
Cursor Rules vs. Memories: What Belongs in EachUse explicit rules for approved instructions and treat remembered context as something to review. Keep changing project progress somewhere the next assistant can read.2026-06-17 · 6 min read
Cursor Rules Generator: Turn Project Facts Into Useful RulesA Cursor rules generator only works well when it pulls from real project facts. Here is how to give it the right source material and review what comes out.2026-06-15 · 6 min read
How to Share Skills Between Claude and Cursor (and Copilot)Some Claude skill instructions translate directly to Cursor and GitHub Copilot. Others need adaptation. Here's what transfers, what needs adjustment, and how to keep the approved reusable guidance in one place.2026-06-15 · 6 min read
Cursor Rules for HTML: Semantics, Forms, and AccessibilityCursor rules for HTML that require semantic structure, accessible form markup, and review checks, with fenbs keeping the agreed content and design requirements each assistant should apply consistently.2026-06-13 · 5 min read
Cursor Rules for UI and UX: Design Decisions in CodePractical Cursor rules for UI and UX work: design tokens, interaction patterns, accessibility, and acceptance checks, with fenbs retaining the approved design decisions and feedback behind them.2026-06-12 · 4 min read