mcpField
P
parallel-exploring

parallel-exploring

github.com/revitalb-portAgent workflows049 installsUpdated 10w ago
Repository

About parallel-exploring

A Cursor skill for exploring large or unfamiliar codebases, intended for onboarding, cross-layer feature investigations, and architecture mapping. It divides research among read-only explore subagents running concurrently, then synthesizes their findings.

Key features

  1. 01Divide investigations by codebase area
  2. 02Launch read-only explore subagents in parallel
  3. 03Map frontend, backend, and infrastructure
  4. 04Summarize stack, architecture, and key files
  5. 05Support cross-cutting investigations and dependency reviews

Use cases

  1. 01Get oriented in a newly inherited project
  2. 02Trace a feature across frontend and backend
  3. 03Assess migration scope across code and tests
  4. 04Review dependency updates and security in parallel

Install

Copy the command and run it in a terminal.

$npx skills add https://github.com/revitalb-port/skills-registry-demo --skill parallel-exploring

After installing, type/parallel-exploringin Claude Code to confirm it loaded.

Details

From the project README

Parallel Explore

Use this skill when you need to understand a large or unfamiliar codebase quickly — onboarding onto a new project, investigating how a feature works across layers, or mapping the architecture.

How It Works

Cursor's explore subagent is a fast, read-only agent optimized for searching and reading code. You can launch multiple explore agents in a single message and they run concurrently, each investigating a different area.

Steps

  1. Identify the areas to explore — break the codebase into logical zones. For a typical full-stack app:

    • Frontend: components, pages, routing, state management
    • Backend: API routes, database models, middleware, auth
    • Infrastructure: CI/CD, Docker, deployment config
    • Shared: types, utilities, constants

  2. Launch parallel explore agents — use the Task tool with subagent_type: "explore" for each area. Launch them all in one message:

    Task 1: "Explore the frontend — find the main pages, routing setup, state management approach,
         and UI component library. Check src/app/, src/components/, src/pages/. Report the
         framework, router, styling approach, and key components."

Task 2: "Explore the backend — find the API routes, database setup, ORM, auth middleware,
         and data models. Check src/server/, src/api/, lib/, prisma/. Report the framework,
         database, auth strategy, and key endpoints."

Task 3: "Explore the infrastructure — find CI/CD config, Docker setup, deployment targets,
         and environment variable management. Check .github/, docker*, *.config.*, .env*.
         Report the deploy target, CI provider, and any IaC."

  3. Synthesize the results — when all agents return, combine their findings into a coherent picture:

    • Tech stack summary (frontend, backend, database, infra)
    • Architecture diagram (describe the data flow)
    • Key files and entry points
    • Potential concerns or tech debt

Other Use Cases

  • Cross-cutting investigation: "Where is user authentication checked?" — launch agents to search the frontend (route guards), backend (middleware), and database (session storage) simultaneously.
  • Dependency audit: launch agents to check different parts of the dependency tree for outdated packages, security issues, and unused imports.
  • Migration planning: have agents simultaneously assess the frontend, backend, and tests to estimate the scope of a framework migration.

Notes

  • Explore agents are read-only — they can't modify files.
  • Use thoroughness: "very thorough" in the prompt for comprehensive analysis.
  • Each agent has its own context window, so they can each read many files without running out of space.
  • For a single focused question, just use Grep or SemanticSearch directly — subagents are for broad exploration.

Comments

Markdown supported