Bridge Scope

Analyze existing software projects to scope changes and draft acceptance criteria.

Updated Aug 27, 2026
One-click install
npx skills add https://github.com/etapsc/bridge --skill bridge-scope
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: Bridge Scope
Source: https://github.com/etapsc/bridge/tree/main/bridge-codex/.agents/skills/bridge-scope
Command: npx skills add https://github.com/etapsc/bridge --skill bridge-scope

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill helps define the scope of a requested change (feature, fix, or extension) within an existing software project, ensuring clarity on impact and approach before development begins.

Core Features & Use Cases

  • Impact Analysis: Identifies files likely to be affected and those that must remain untouched.
  • Approach Definition: Outlines a high-level strategy for implementing the change.
  • Acceptance Criteria: Drafts initial criteria to define successful completion.
  • Use Case: When a user requests to add a new authentication method to a web application, this Skill analyzes the current codebase, suggests affected files (e.g., auth modules, user models), proposes an implementation strategy, and drafts acceptance tests.

Quick Start

Use the bridge-scope skill to scope a new user profile editing feature.

Frequently Asked Questions about Bridge Scope

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I scope changes for an existing software project before development begins?

To scope changes for an existing software project, you analyze the current state, define the change type, identify affected files and dependencies, outline an implementation approach, and draft acceptance criteria to ensure clarity on impact.

What is included in a software project impact analysis?

A software project impact analysis identifies specific files likely to be affected by a requested change, highlights dependencies within your defined tech stack, and flags files that must remain untouched to mitigate potential risks.

How do I define an implementation approach for a new feature in an existing codebase?

Defining an implementation approach involves analyzing existing patterns in your codebase and outlining a high-level strategy to integrate the requested change, ensuring the proposed development aligns with your current tech stack.

Can I use this to draft acceptance criteria for a new authentication method?

Yes, you can scope a new authentication method by analyzing the current codebase, suggesting affected files like auth modules and user models, proposing an implementation strategy, and drafting initial acceptance tests for successful completion.

What's the best way to identify potential risks and affected files when modifying existing software?

The best way to identify potential risks and affected files is through systematic codebase analysis, which evaluates the requested change against existing patterns to pinpoint necessary modifications and prevent unintended side effects in untouched modules.