discover-patterns

Discover implicit architectural and implementation patterns in Go, TypeScript, and infrastructure codebases.

9|Updated Mar 22, 2026
One-click install
npx skills add https://github.com/paultyng/skill-issue --skill discover-patterns-paultyng
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: discover-patterns
Source: https://github.com/paultyng/skill-issue/tree/main/skills/discover-patterns
Command: npx skills add https://github.com/paultyng/skill-issue --skill discover-patterns-paultyng

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Manually identifying undocumented architectural and implementation patterns across a codebase is time-consuming and error-prone, leading to inconsistent code, unreviewed technical debt, and inefficient code reviews that miss deviations from established conventions.

Core Features & Use Cases

  • Automated Pattern Discovery: Identifies implicit patterns across structure & layering, error handling, observability, configuration, dependency injection, testing, and transport layers using parallel codebase analysis.
  • Consistency Quantification: Classifies each discovered pattern as established, emerging, or inconsistent to highlight areas where code deviates from common team or project conventions.
  • Use Case: When onboarding to a new large codebase, use this skill to generate a patterns document that aligns future contributions with existing standards and gives reviewers a clear baseline for conformance checks.

Quick Start

Use the discover-patterns skill to analyze the current project codebase and generate a structured patterns document for the engineering team to reference during code reviews.

Frequently Asked Questions about discover-patterns

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

FAQPage Schema
How do I discover undocumented architectural patterns in a codebase?

Codebase pattern discovery identifies implicit architectural and implementation standards using parallel analysis. It classifies patterns across structure, error handling, and observability as established, emerging, or inconsistent to guide standardization without manual codebase traversal.

What is the best way to check code review conformance against existing conventions?

Code review conformance checking compares new code against discovered architectural patterns. It generates a patterns document with quantified consistency metrics and counter-example identification, giving reviewers a clear baseline to catch deviations from established conventions.

Can I audit architecture patterns across Go, TypeScript, and infrastructure code?

Architecture auditing applies to Go, TypeScript, and infrastructure code. It analyzes structure, layering, dependency injection, and transport layers to highlight areas where code deviates from common project conventions and contributes to technical debt.

How do I quantify technical debt from inconsistent coding patterns during onboarding?

Consistency quantification measures technical debt by classifying discovered implementation patterns as established, emerging, or inconsistent. It provides exemplar references and counter-examples to quantify deviations from implicit coding standards across the source codebase.

Does automated pattern discovery work for large codebases without manual traversal?

Automated pattern discovery works for large codebases using parallel codebase analysis. It eliminates manual codebase traversal by identifying implicit patterns and generating a structured document for engineering teams to reference during onboarding and reviews.