Engineering Advanced CursorAI EditorRules

Cursor Rules Engineer

Create optimized .cursorrules and AI editor configuration files from codebase analysis. Boost AI coding assistant accuracy and consistency.

A meta-engineering skill that analyzes your codebase and generates optimized AI editor configuration — .cursorrules, .cursor/rules/*.mdc, and related files. It identifies your tech stack, coding conventions, testing patterns, and anti-patterns, then encodes them into rules that make AI coding suggestions consistent with your actual codebase.

Added Mar 20, 2026

$npx skills add johnefemer/skillfish --skill cursor-rules-engineer

Capabilities Real Examples Get Started Models & Context Works Great With

What This Skill Can Do

Concrete capabilities you get when you install this skill.

Analyze a codebase and extract implicit conventions for AI editor rules

Generate .cursorrules and .cursor/rules/*.mdc files from codebase patterns

Write scoped rules (auto-attached vs always-on) for different file types and directories

Encode project-specific anti-patterns as negative rules to prevent AI regressions

Create rules for test file patterns, import conventions, and naming standards

Audit existing cursor rules for conflicts, redundancy, and missing coverage

Real Conversations

See how the Cursor Rules Engineer skill responds to actual requests. These are representative examples of what your AI agent will produce.

You

I have a React + TypeScript monorepo. Can you help me create effective cursor rules based on our codebase conventions?

Agent

To generate accurate rules, I need to analyze your codebase patterns first. Share samples of:

A typical component file
A typical hook
A test file
Your tsconfig.json and any eslint config

Based on common React/TypeScript monorepo patterns, here's a starting template to customize:

# .cursor/rules/react-typescript.mdc
---
glob: "**/*.{tsx,ts}"
---

## TypeScript Conventions
- Use `type` for object shapes, `interface` for class contracts and extension
- Prefer `const` assertions and `satisfies` over type casting
- No `any` — use `unknown` and narrow with type guards

## React Patterns
- Functional components only — no class components
- Custom hooks in `src/hooks/use*.ts`, co-located with feature if single-use
- Component props: inline type definitions for simple props, named `type ComponentNameProps` for reuse
- Event handlers: `handle` prefix (handleClick, handleSubmit)

## Imports
- Absolute imports via `@/` alias (maps to `src/`)
- Group: external deps → internal modules → relative imports → styles
- No barrel re-exports from index.ts (causes circular dep risk)

## Testing
- Tests co-located: `ComponentName.test.tsx` next to `ComponentName.tsx`
- Use `testing-library/react` — no Enzyme
- Prefer `userEvent` over `fireEvent` for interaction tests

## Anti-patterns (never generate these)
- `useEffect` for data fetching — use React Query or SWR
- Inline styles — use Tailwind classes or CSS modules
- Default exports from non-page components

Share your actual files and I'll refine the rules to match your real conventions precisely.

You

Our AI coding assistant keeps generating try/catch blocks everywhere but we use a Result type pattern instead. How do I encode this as a cursor rule?

Agent

This is exactly what negative rules and positive examples are for. Here's how to encode your Result pattern:

# .cursor/rules/error-handling.mdc
---
alwaysApply: true
---

## Error Handling — Result Pattern

This codebase uses a Result type for error handling. NEVER use try/catch for application errors.

### The Result type
```ts
type Result<T, E = Error> =
  | { ok: true; value: T }
  | { ok: false; error: E };

function ok<T>(value: T): Result<T> { return { ok: true, value }; }
function err<E>(error: E): Result<never, E> { return { ok: false, error }; }

Always do this

async function fetchUser(id: string): Promise<Result<User, ApiError>> {
  const res = await fetch(`/api/users/${id}`);
  if (!res.ok) return err(new ApiError(res.status));
  return ok(await res.json());
}

const result = await fetchUser(id);
if (!result.ok) {
  logger.warn('fetchUser failed', result.error);
  return;
}
console.log(result.value.name);

Never do this

// WRONG — never generate try/catch for application errors
try {
  const user = await fetchUser(id);
} catch (e) {
  console.error(e);
}

Exceptions (where try/catch IS appropriate): top-level error boundaries, third-party library calls that throw by contract (JSON.parse, crypto operations).


The key is the concrete before/after example with explicit `NEVER` instructions — AI editors treat these as strong negative constraints.

Get Started

How to install and use this skill in your preferred environment.

Skills are designed for AI coding agents (Claude Code, Cursor, Windsurf) and IDE-based workflows where the agent can read files, run scripts, and act on your codebase.

Models & Context

Which AI models and context windows work best with this skill.

Recommended Models

Works well with Claude Sonnet or GPT-4o. Codebase analysis and rule generation benefits from models that can reason about code patterns and conventions.

Context Window

SKILL.md is ~7KB. Load representative source files and existing rules in context — the more codebase samples, the more accurate the generated rules.

Pro tips for best results

1

Be specific

Include numbers — users, budget, RPS — so the skill can size the architecture.

2

Share constraints

Compliance needs, team size, and existing stack all improve the output.

3

Iterate

Start with a high-level design, then ask follow-ups for IaC, cost analysis, or security review.

4

Combine skills

Pair with companion skills below for end-to-end coverage.

Works Great With

These skills complement Cursor Rules Engineer for end-to-end coverage. Install them together for better results.

Claude Code Config

Generate optimized CLAUDE.md files, memory configs, and project instructions for Claude Code. Analyzes codebase to create tailored AI context.

Claude CodeCLAUDE.md

Codebase Onboarding

Auto-generate onboarding docs from codebase analysis.

OnboardingDocumentation

Senior Fullstack

Fullstack development with Next.js, FastAPI, MERN, and Django stacks.

FullstackNext.js

Self-Improving Agent

Curate auto-memory into durable project knowledge, promote patterns to rules.

AgentMemory

$ skillfish add johnefemer/skillfish --all # install all skills at once

Ready to try Cursor Rules Engineer?

Install the skill and start getting expert-level guidance in your workflow — any agent, any IDE.