New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Cursor Local Dev Loop

by jeremylongshore in jeremylongshore/tons-of-skills-marketplace

Optimize daily development workflow with Cursor IDE using Chat, Composer, Tab, and Git integration.

MITAuto-check passedDevelopment

Install Cursor Local Dev Loop

skills CLI
$ npx skills add jeremylongshore/tons-of-skills-marketplace --skill cursor-local-dev-loop -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install jeremylongshore/tons-of-skills-marketplace cursor-local-dev-loop --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/jeremylongshore/tons-of-skills-marketplace.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/.curated/cursor-local-dev-loop .claude/skills/cursor-local-dev-loop && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
cursor-local-dev-loop
GitHub stars
2.8k
Token cost
~2.1k tokens
SKILL.md length
551 words
Files
4 (incl. references)
Skills in repo
3,342
Repo updated
First seen
Licence
MIT

At a glance

Optimize daily development workflow with Cursor IDE using Chat, Composer, Tab, and Git integration.

  • Works in 7 steps: Plan (Chat) → Scaffold (Composer) → Implement (Tab Completion) → …
  • Cursor workflow
  • SKILL.md covers Overview, Prerequisites, Instructions and Output, plus 13 more sections
  • Calls npm

What it does

Cursor Local Dev Loop is an agent skill from jeremylongshore/tons-of-skills-marketplace. Optimize daily development workflow with Cursor IDE using Chat, Composer, Tab, and Git integration. Triggers on "cursor workflow", "cursor development loop", "cursor productivity", "cursor daily workflow", "cursor dev flow".

Its SKILL.md is about 2.1k tokens, which your agent loads only when the skill is triggered. The skill folder holds 4 other files, including reference files (for example `references/errors.md`, `references/examples.md` and `references/optimal-development-workflow.md`). Compatibility notes: Designed for Claude Code

It sits in Development, covering Git workflow. It works with Git. The repository describes itself as: Model-agnostic agent-skills platform with a harness-free canonical layer, verified adapters, and the ccpi package manager. Explore at tonsofskills.com. The licence is MIT.

When your agent uses it

  • Cursor workflow
  • Cursor development loop
  • Cursor productivity
  • Cursor daily workflow

Example prompts

  • “cursor workflow”
  • “cursor development loop”
  • “cursor productivity”
  • “/cursor-local-dev-loop”

Requirements

  • Compatibility (from SKILL.md): Designed for Claude Code
  • Pre-approved tools (allowed-tools): Read, Write, Edit, Bash(cmd:*)

Workflow steps

7 steps, taken from the step headings in SKILL.md.

  1. Plan (Chat)
  2. Scaffold (Composer)
  3. Implement (Tab Completion)
  4. Refine (Inline Edit)
  5. Test (Chat + Terminal)
  6. Commit (AI Messages)
  7. Review (@Git)

What it can do on your machine

Read from SKILL.md and the folder at commit 80f86df. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Read
    • Write
    • Edit
    • Bash(cmd:*)

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • npm

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Links to these hosts (documentation or services it may open):

    • docs.cursor.com
    • cursor.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

  • Compatibility

    Designed for Claude Code

    From compatibility in the SKILL.md frontmatter.

Context cost

Cursor Local Dev Loop loads about 2.1k tokens when it runs, and up to ~2.8k if it reads all its reference files. Until then it costs about 62 tokens; SKILL.md has 551 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~62
When it runs · the whole SKILL.md, loaded when a task matches
~2.1k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~2.8k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from jeremylongshore/tons-of-skills-marketplace at commit 80f86df, republished under its MIT licence (© jeremylongshore). 551 words, ~2,142 tokens.

Download SKILL.mdSave it as .claude/skills/cursor-local-dev-loop/SKILL.md (or your agent's skills folder). This skill also uses 3 other files; get the full folder from GitHub.
name
cursor-local-dev-loop
description
Optimize daily development workflow with Cursor IDE using Chat, Composer, Tab, and Git integration. Triggers on "cursor workflow", "cursor development loop", "cursor productivity", "cursor daily workflow", "cursor dev flow".
allowed-tools
Read, Write, Edit, Bash(cmd:*)
compatibility
Designed for Claude Code
version
1.19.0
license
MIT
author
Jeremy Longshore <jeremy@intentsolutions.io>
tags
saas, cursor, workflow

Cursor Local Dev Loop

Overview

Use Cursor inside the normal local development loop: small scoped change, inspect diff, run focused checks, commit reviewed work, and retain a rollback path.

Prerequisites

  • A clean or recoverable branch, repository instructions, and required local test/format commands.
  • Approved privacy settings and exclusion of secrets, production exports, and unrelated repositories.

Instructions

  1. Start with a narrow issue and affected-file list, then use Chat/Inline Edit/Composer only for that scope.
  2. Inspect every proposed diff and run the narrowest relevant formatter, test, and static check.
  3. Commit one reviewed change at a time and use normal pull-request/branch rules for integration.
  4. Revert rather than patching around an AI-generated regression when a focused check fails.

Output

  • A small reviewed local change with validation evidence and an ordinary git rollback path.

Error Handling

ConditionSafe response
Generated change is broadReject/split it before applying.
Test failsDiagnose and revert or fix within scope; do not disable the test.
Working tree is mixedStash or commit unrelated user work before continuing.

Examples

Ask Inline Edit to update one function, inspect the diff, run that function's focused test, and commit it separately. If the test fails or unrelated files change, reject/revert and restate the task with tighter constraints.

Establish a productive daily development workflow using Cursor's AI features at each stage of the code-write-test-commit cycle.

The AI-Augmented Development Loop

┌─────────────────────────────────────────────────────────────┐
│  1. PLAN        →  Chat (Cmd+L) with @Codebase, @Docs      │
│  2. SCAFFOLD    →  Composer (Cmd+I) for new files           │
│  3. IMPLEMENT   →  Tab completion for line-by-line coding   │
│  4. REFINE      →  Inline Edit (Cmd+K) for targeted fixes  │
│  5. TEST        →  Chat to generate tests, terminal to run  │
│  6. COMMIT      →  AI-generated commit messages             │
│  7. REVIEW      →  @Git for branch diff review              │
└─────────────────────────────────────────────────────────────┘

Stage 1: Plan (Chat)

Start each task by discussing architecture with Chat:

@Codebase @Docs Prisma

I need to add a "favorites" feature where users can bookmark products.
What's the best approach given our current data model and API structure?
Consider: database schema, API endpoints, and frontend hooks.

Chat excels at:

  • Architecture decisions before writing code
  • Evaluating trade-offs (SQL join table vs JSON array, REST vs GraphQL)
  • Understanding existing patterns via @Codebase

Stage 2: Scaffold (Composer)

Once the plan is clear, use Composer for multi-file generation:

@src/api/users/route.ts @prisma/schema.prisma

Create the favorites feature:
1. prisma/schema.prisma: Favorite model (userId, productId, createdAt)
2. src/api/favorites/route.ts: GET (list user favorites), POST (add), DELETE (remove)
3. src/services/favorite.service.ts: FavoriteService with Prisma operations
4. src/hooks/useFavorites.ts: React hook with optimistic updates
Follow existing patterns from the users API.

Tip: Reference existing files with @ so Composer replicates your patterns instead of inventing new ones.

Stage 3: Implement (Tab Completion)

With scaffolded files open, use Tab for implementation details:

typescript
// Open favorite.service.ts and start typing:
async toggleFavorite(userId: string, productId: string

// Tab completes the full method:
async toggleFavorite(userId: string, productId: string): Promise<Favorite | null> {
  const existing = await this.prisma.favorite.findUnique({
    where: { userId_productId: { userId, productId } },
  });
  if (existing) {
    await this.prisma.favorite.delete({ where: { id: existing.id } });
    return null;
  }
  return this.prisma.favorite.create({ data: { userId, productId } });
}

Workflow tips for Tab:

  • Open related files in tabs (service, types, API route) -- Tab reads open tabs for context
  • Write type signatures first -- Tab generates better bodies when types are explicit
  • Accept partially with Cmd+→ when the suggestion is 80% right
Show full SKILL.md (204 more words)Show less

Stage 4: Refine (Inline Edit)

For targeted improvements, select code and use Cmd+K:

Select the toggleFavorite method → Cmd+K:
"Add input validation: userId and productId must be non-empty strings.
 Add error handling for database connection failures.
 Return a Result type instead of throwing."

Other common Cmd+K workflows:

  • "Add JSDoc comments" on a function
  • "Convert to async/await" on a Promise chain
  • "Add null checks" on a code block
  • "Optimize this query" on a database call

Stage 5: Test (Chat + Terminal)

Generate tests via Chat:

@src/services/favorite.service.ts @tests/services/user.service.test.ts

Generate vitest tests for FavoriteService following the same patterns as
user.service.test.ts. Cover: addFavorite, removeFavorite, toggleFavorite,
getFavorites with pagination. Mock Prisma client.

Run tests in the integrated terminal:

bash
# Cmd+` to open terminal
npm test -- --watch src/services/favorite.service.test.ts

If tests fail, paste the error into Chat:

@src/services/favorite.service.ts
This test is failing with: "Expected null but received undefined"
[paste test output]
What's wrong?

Stage 6: Commit (AI Messages)

Use Cursor's Source Control panel (Cmd+Shift+G):

  1. Stage changed files
  2. Click the sparkle icon (AI) next to the commit message input
  3. Cursor generates a commit message from the diff:
feat: add favorites feature with toggle, pagination, and optimistic updates

- Add Favorite model to Prisma schema with userId/productId unique constraint
- Create REST API endpoints (GET, POST, DELETE) for /api/favorites
- Implement FavoriteService with toggleFavorite and paginated listing
- Add useFavorites React hook with optimistic UI updates

Stage 7: Review (@Git)

Before pushing, review your full branch diff:

@Git

Review all changes in this branch compared to main.
Check for:
- Missing error handling
- Type safety issues
- Potential N+1 query problems
- Any hardcoded values that should be environment variables

@Git includes the branch diff in context, giving the AI a complete view of all your changes.

Daily Efficiency Tips

Session Management
Morning startup:
1. cursor .                          # Open project
2. Wait for "Indexed" in status bar  # Indexing complete
3. Cmd+Shift+G → git pull           # Sync with team
4. Cmd+L → "What changed yesterday? @Git"

Task switching:
- Start a new Chat (Cmd+N) for each task
- Do NOT continue a 20-turn conversation on a new topic
Keyboard-Driven Flow

Minimize mouse usage:

Cmd+P          →  Open any file by name
Cmd+Shift+P    →  Run any command
Cmd+L          →  Ask AI anything
Cmd+K          →  Edit selected code
Cmd+I          →  Multi-file changes
Cmd+`          →  Toggle terminal
Cmd+B          →  Toggle sidebar
Cmd+Shift+G    →  Git panel
Project Rules for Consistency

Create .cursor/rules/dev-standards.mdc:

yaml
---
description: "Development standards for all code"
globs: ""
alwaysApply: true
---
- Run `npm test` before committing
- All new functions need JSDoc comments
- Use Conventional Commits format
- No console.log in committed code (use proper logger)

Enterprise Considerations

  • Reproducible workflows: Document the AI-augmented workflow in team runbooks
  • Code review: AI-generated code still needs human review -- Composer output is a first draft
  • Onboarding: New team members can use Chat with @Codebase to explore unfamiliar code
  • Metrics: Track time-to-feature before and after Cursor adoption to quantify ROI

Resources

© jeremylongshore, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 3 other files (references) in skills/.curated/cursor-local-dev-loop of jeremylongshore/tons-of-skills-marketplace.

  • SKILL.md
  • references/errors.md
  • references/examples.md
  • references/optimal-development-workflow.md

Open the folder on GitHubat commit 80f86df

Compare with similar skills

Cursor Local Dev Loop next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Cursor Local Dev Loop compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Cursor Local Dev Loop this skilljeremylongshore/tons-of-skills-marketplace2.8k—~2.1kAutomated safety check: PassMIT
Finishing a Development Branchobra/superpowers297k5 repos~1.9kAutomated safety check: PassMIT
Code Design Rationale Investigatorcursor/plugins10k9 repos~2.6kAutomated safety check: PassNone
Contributor-First PR MergeHKUDS/OpenHarness16k1 repos~847Automated safety check: PassMIT
Migrate Internal Package into GhostTryGhost/Ghost56k—~3.8kAutomated safety check: PassMIT
Create Pull Requestcline/cline70k1 repos~1.6kAutomated safety check: PassApache-2.0

Similar skills

  • Finishing a Development Branch

    obra/superpowers

    Walks the last step of a branch: confirm tests pass, detect the git environment, ask how to integrate, carry out your choice and clean up the worktree.

    297k GitHub starsUsed in 5 repos~1.9k tokens
    DevelopmentAuto-check passed

  • Code Design Rationale Investigator

    cursor/plugins

    Official

    Digs into why code is shaped the way it is by checking git history, pull requests and connected tools in parallel, then reporting a cited read on the tradeoffs.

    10k GitHub starsUsed in 9 repos~2.6k tokens
    DevelopmentAuto-check passed

  • Contributor-First PR Merge

    HKUDS/OpenHarness

    Merges external GitHub pull requests while keeping the original author credited, and fixes conflicts after the merge instead of rewriting the contribution.

    16k GitHub starsUsed in 1 repo~847 tokens
    DevelopmentAuto-check passed

  • Migrate Internal Package into Ghost

    TryGhost/Ghost

    Moves a package from another TryGhost repository into Ghost as an internal workspace package while keeping its Git history, with checkpoints for the steps that need an administrator.

    56k GitHub stars~3.8k tokensUpdated today
    DevelopmentAuto-check passed

  • Create Pull Request

    cline/cline

    Opens a GitHub pull request from your current branch with the gh CLI, after reviewing the commits and diff and gathering the details the PR needs.

    70k GitHub starsUsed in 1 repo~1.6k tokens
    DevelopmentAuto-check passed

  • Git Merge Conflict Resolver

    tailcallhq/forgecode

    Resolves Git merge conflicts with a plan-first workflow that keeps both sides' intent, regenerates lock files and backs up deleted-but-modified files.

    7.6k GitHub starsUsed in 1 repo~4.5k tokens
    DevelopmentAuto-check passed

More from jeremylongshore/tons-of-skills-marketplace

All 3,342 skills in this repo

  • Performing Security Code Review

    jeremylongshore/tons-of-skills-marketplace

    Execute this skill enables AI assistant to conduct a security-focused code review using the security-agent plugin.

    2.8k GitHub starsUsed in 2 repos~1.3k tokens
    Auto-check: notes

  • Adapting Transfer Learning Models

    jeremylongshore/tons-of-skills-marketplace

    Build this skill automates the adaptation of pre-trained machine learning models using transfer learning techniques.

    2.8k GitHub stars~1.1k tokensUpdated today
    Auto-check passed

  • Agent Context Loader

    jeremylongshore/tons-of-skills-marketplace

    Execute proactive auto-loading: automatically detects and loads agents.md files.

    2.8k GitHub stars~1.1k tokensUpdated today
    Auto-check passed

  • Aggregating Performance Metrics

    jeremylongshore/tons-of-skills-marketplace

    Aggregate and centralize performance metrics from applications, systems, databases, caches, and services.

    2.8k GitHub stars~1.2k tokensUpdated today
    Auto-check passed

  • Analyzing Capacity Planning

    jeremylongshore/tons-of-skills-marketplace

    Execute this skill enables AI assistant to analyze capacity requirements and plan for future growth.

    2.8k GitHub stars~947 tokensUpdated today
    Auto-check passed

  • Analyzing Database Indexes

    jeremylongshore/tons-of-skills-marketplace

    Process use when you need to work with database indexing. An agent skill from jeremylongshore/tons-of-skills-marketplace.

    2.8k GitHub stars~2k tokensUpdated today
    Auto-check passed

Works with

Categories

Questions about Cursor Local Dev Loop

What does Cursor Local Dev Loop do?

Optimize daily development workflow with Cursor IDE using Chat, Composer, Tab, and Git integration. Cursor Local Dev Loop is an agent skill from jeremylongshore/tons-of-skills-marketplace. Optimize daily development workflow with Cursor IDE using Chat, Composer, Tab, and Git integration.

When should I use Cursor Local Dev Loop?

Cursor Local Dev Loop fits situations like: Cursor workflow; Cursor development loop; Cursor productivity; Cursor daily workflow.

How do I install Cursor Local Dev Loop in Claude Code?

Run `npx skills add jeremylongshore/tons-of-skills-marketplace --skill cursor-local-dev-loop -a claude-code`. Or copy the skill folder (skills/.curated/cursor-local-dev-loop in jeremylongshore/tons-of-skills-marketplace) into .claude/skills/cursor-local-dev-loop in your project. Claude Code loads it when a task matches its description.

How do I install Cursor Local Dev Loop in Codex?

Run `npx skills add jeremylongshore/tons-of-skills-marketplace --skill cursor-local-dev-loop -a codex`. Or copy the skill folder (skills/.curated/cursor-local-dev-loop in jeremylongshore/tons-of-skills-marketplace) into .agents/skills/cursor-local-dev-loop in your project. Codex loads it when a task matches its description.

Can I use Cursor Local Dev Loop in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add jeremylongshore/tons-of-skills-marketplace --skill cursor-local-dev-loop -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/cursor-local-dev-loop, .gemini/skills/cursor-local-dev-loop, .github/skills/cursor-local-dev-loop and .opencode/skills/cursor-local-dev-loop in your project.

What does Cursor Local Dev Loop need to run?

Going by SKILL.md and its folder, Cursor Local Dev Loop needs the command-line tools its instructions call (npm). Its frontmatter pre-approves these tools: Read, Write, Edit, Bash(cmd:*). Compatibility (from SKILL.md): Designed for Claude Code.

Does Cursor Local Dev Loop access the network?

SKILL.md names 2 domains. As links in the text: docs.cursor.com and cursor.com. This is read from the text; nothing was executed.

Is Cursor Local Dev Loop safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Cursor Local Dev Loop use?

Cursor Local Dev Loop is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Cursor Local Dev Loop use?

About 2.1k tokens (SKILL.md is roughly 8.6k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 679 tokens, read only when the agent opens those files.

What are the alternatives to Cursor Local Dev Loop?

Skills that share tags, products or a category with Cursor Local Dev Loop: Finishing a Development Branch (obra/superpowers, 297k stars), Code Design Rationale Investigator (cursor/plugins, 10k stars), Contributor-First PR Merge (HKUDS/OpenHarness, 16k stars) and Migrate Internal Package into Ghost (TryGhost/Ghost, 56k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Cursor Local Dev Loop?

jeremylongshore (a GitHub user) maintains it in jeremylongshore/tons-of-skills-marketplace, which has 2,825 GitHub stars. The repository holds 3,342 skills in this directory. The repository was last updated on October 9, 2026.

Source: jeremylongshore/tons-of-skills-marketplace on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.