/speckit.check-integration

description: Validates that tasks.md considers existing codebase implementations and integration opportunities before execution. Use when you need to check task alignment with the current codebase.
argument-hint: "[optional-criteria]"
allowed-tools: Read, Glob, Grep, Bash

Check Task Integration with Codebase

Overview

Validates that tasks.md considers existing codebase implementations and integration opportunities before execution. Use when you need to check task alignment with the current codebase.

Usage

/speckit.check-integration $ARGUMENTS

Arguments

| Argument | Description | |--------------|------------------------------------------| | `$ARGUMENTS` | Combined arguments passed to the command |

Execution Steps

Execution Instructions

**Agent Selection**: To execute this task, use the following approach:

• Primary: Use `general-purpose` agent with appropriate domain expertise
• Or use specialized agent if available for the specific task type

User Input

$ARGUMENTS

You **MUST** consider the user input before proceeding (if not empty).

Outline

**Goal**: Analyze tasks.md to verify each task considers existing codebase implementations, integration opportunities, and architectural compatibility. This is a READ-ONLY analysis command that reports findings without modifying any files.

**When to run**: After `/speckit.tasks` generates tasks.md but BEFORE `/speckit.implement` executes them.

**Critical Principle**: This command NEVER modifies code, tasks, or any files. It only analyzes and reports.

1. Setup & Prerequisites

Run `.specify/scripts/bash/check-prerequisites.sh --json --require-tasks --include-tasks` from repo root and parse JSON for:

• FEATURE_DIR (absolute path)
• TASKS file path
• AVAILABLE_DOCS list

For single quotes in args like "I'm Groot", use escape syntax: e.g 'I'\''m Groot' (or double-quote if possible: "I'm Groot").

Abort if tasks.md is missing with error: "No tasks.md found. Run `/speckit.tasks` first."

2. Load Context

**Required files**:

• tasks.md: Complete task list with file paths and descriptions
• plan.md: Tech stack, architecture, dependencies
• spec.md: Feature requirements and scope

**Optional files** (load if present):

• data-model.md: Entity definitions
• contracts/: API specifications
• research.md: Technical decisions

**Codebase scan**:

• Identify project root structure (src/, lib/, components/, etc.)
• List existing dependencies from package.json/requirements.txt/etc.
• Map existing modules, services, utilities, components
• Identify configuration files (database, API, environment)

3. Build Codebase Inventory

Create internal mapping of existing implementations:

**Infrastructure & Configuration**:

• Database setup, migrations, ORM configurations
• API framework initialization (Express, FastAPI, etc.)
• Authentication/authorization systems
• Logging, monitoring, error handling utilities
• Environment configuration patterns

**Data Layer**:

• Existing models/entities with fields and relationships
• Database access patterns (repositories, DAOs)
• Data validation utilities
• Schema management approaches

**Service Layer**:

• Business logic services
• Integration services (external APIs, third-party)
• Utility services (email, notifications, file handling)
• Caching mechanisms

**API Layer**:

• Existing endpoints and route patterns
• Request/response handlers
• Middleware (auth, validation, error handling)
• API versioning approach

**UI Components** (if applicable):

• Component library and design system
• Layout components
• Shared utilities (hooks, contexts)
• State management patterns

**Testing Infrastructure**:

• Test frameworks and utilities
• Mock/fixture patterns
• Test database setup
• CI/CD test integration

4. Analyze Each Task

For every task in tasks.md, perform this structured analysis:

A. Existing Implementation Detection

**Scan for**:

• Similar functionality already implemented
• Overlapping components/modules
• Duplicate data models or entities
• Redundant API endpoints
• Existing utilities that solve the same problem

**Output for each finding**:

EXISTING: [File path]
Lines: [Line range]
Description: [What it does]
Similarity: [HIGH/MEDIUM/LOW]
Reason: [Why it's relevant to this task]

B. Integration Opportunity Analysis

**Check if task can**:

• Extend existing components rather than create new ones
• Reuse existing utilities/helpers
• Integrate with established patterns
• Leverage installed dependencies
• Follow existing architectural patterns

**Output for each opportunity**:

INTEGRATION: [Approach]
With: [Existing component/pattern]
Benefit: [Why integration is better than from-scratch]
Risk: [Potential conflicts or limitations]

C. Dependency & Library Check

**Verify**:

• Required libraries already installed
• Similar functionality in existing dependencies
• Configuration already present
• Patterns already established in codebase

**Output**:

DEPENDENCY: [Package/library name]
Status: [INSTALLED/NOT_INSTALLED]
Usage: [Where used in codebase]
Alternative: [If similar functionality exists]

D. Architectural Compatibility

**Assess**:

• Task aligns with existing architecture
• File structure matches project conventions
• Naming conventions consistency
• Design patterns compatibility

**Output**:

COMPATIBILITY: [ALIGNED/PARTIAL/MISALIGNED]
Architecture: [Current pattern in codebase]
Task Approach: [What task proposes]
Concern: [If any conflicts detected]

5. Task-Level Evaluation

For each task, answer these questions:

**Integration Assessment**:

• [ ] CONSIDERS - Task explicitly mentions existing code to integrate with
• [ ] PARTIAL - Task could integrate but doesn't mention existing code
• [ ] IGNORES - Task proposes from-scratch solution when integration possible
• [ ] NEW - Task is genuinely new, no existing code applies

**Codebase Awareness*