implementation-context

Scan neighboring files to summarize local code conventions for implementation.

Updated Feb 20, 2026
One-click install
npx skills add https://github.com/yearofthedan/weaver --skill implementation-context
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: implementation-context
Source: https://github.com/yearofthedan/weaver/tree/main/.claude/skills/implementation-context
Command: npx skills add https://github.com/yearofthedan/weaver --skill implementation-context

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It helps developers quickly understand local code conventions and reusable components before writing new code, ensuring implementations fit the existing codebase rather than just passing tests.

Core Features & Use Cases

  • Neighborhood scan: Reads 2–3 related files to capture patterns in error handling, naming, imports, tests, and input handling.
  • Pattern extraction: Summarizes conventions for error handling, naming, imports, test structure, and edge‑case handling.
  • Reusable code identification: Finds existing utilities, test helpers, and error definitions to avoid duplication.
  • Note generation: Records findings in the agent’s notes for reference during implementation.

Use case: When adding a new operation or fixing a feature, run this skill to align with existing style and reuse code.

Quick Start

Ask the skill to review nearby code and provide a concise summary of relevant patterns before you start implementing the new feature.

Frequently Asked Questions about implementation-context

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

FAQPage Schema
How do I ensure new code matches existing codebase conventions before implementing a feature?

To ensure new code matches existing codebase conventions, you can scan 2-3 neighboring files to extract patterns for error handling, naming, imports, and tests, generating a structured note to guide your implementation.

What is local code pattern extraction and how does it help when modifying functionality?

Local code pattern extraction analyzes nearby repository files to summarize conventions and reusable components. It helps when modifying functionality by ensuring new implementations fit the existing codebase rather than just passing tests.

How do I find reusable utilities and test helpers in a repository to avoid code duplication?

To find reusable utilities and test helpers and avoid code duplication, perform a neighborhood scan of related files to identify existing error definitions and test structures that can be directly reused.

Can I use this pattern extraction approach without executing any code in my repository?

Yes, you can use this pattern extraction approach without executing code. It requires only the ability to access the repository file system to read files and produce a structured note for the agent.

When do I need to analyze codebase conventions before adding a new operation?

You need to analyze codebase conventions before adding a new operation when you want to align with existing style and reuse code. This prevents introducing inconsistent patterns or duplicating existing utilities.

What's the best way to summarize error handling and naming conventions from neighboring files?

The best way to summarize error handling and naming conventions is to read 2-3 related files and extract patterns on edge-case handling, imports, and test structures, recording the findings in a concise reference note.