reatom-extension-candidates

Detect repeated Reatom patterns and triage extension candidates with evidence.

4|Updated May 12, 2026

Search Tags:#architecture #code refactoring #dependency discovery #upstream contribution #reatom #extension patterns #reusables

Ready to run

npx skills add https://github.com/Guria/reatom-skill --skill reatom-extension-candidates

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: reatom-extension-candidates
Source: https://github.com/Guria/reatom-skill/tree/main/skills/reatom-extension-candidates
Command: npx skills add https://github.com/Guria/reatom-skill --skill reatom-extension-candidates

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

It helps you identify repeated Reatom wiring and extension opportunities in an existing codebase, so you can reduce duplication while avoiding premature or incorrect abstractions.

Core Features & Use Cases

Pattern discovery & triage: locates repeated primitive-shaped code (atoms/actions/forms/routes) and classifies it into core, reusables, local extension, local factory, or inline.
Decision ladder for reuse quality: applies upstream-to-reusables signals and minimum-bar criteria to judge what is generic enough to promote.
Evidence-first reporting: produces a quick triage table and detailed findings with file-path evidence and a defensible abstraction recommendation.

Quick Start

Ask: "Scan my codebase for repeated Reatom patterns and report the strongest extension or reusable candidates with evidence, then tell me whether each should be core, reusables, a local extension, a local reatom* factory, or left inline."

Frequently Asked Questions about reatom-extension-candidates

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

FAQPage Schema

How do I find reusable Reatom patterns in my codebase without creating premature abstractions?▼

To find reusable Reatom patterns without over-abstraction, locate repeated primitive-shaped code like atoms or actions and classify each instance against a strict decision ladder to determine if it belongs in core, reusables, or should remain inline. This evidence-based triage prevents incorrect abstractions during refactoring.

How do I triage repeated Reatom code for upstream contribution proposals?▼

Triage repeated Reatom code for upstream contribution by applying a decision ladder that checks minimum-bar criteria and upstream-to-reusables signals. Classify the patterns as core, reusables, or local extensions, and validate candidates using optional upstream checklist criteria to prepare a defensible proposal.

When should I leave duplicated Reatom wiring inline instead of extracting a local extension?▼

Leave duplicated Reatom wiring inline when the pattern fails to meet the minimum-bar criteria for generic reuse during the triage ladder evaluation. If the code is too specific to your local codebase context and lacks evidence of broad applicability, extracting a local extension would risk over-abstraction.

Can I use this triage process for active bug-debugging and bootstrap ordering issues in Reatom?▼

This triage process explicitly excludes active bug-debugging and bootstrap ordering work, targeting instead existing codebases during refactoring audits and dependency decisions. It focuses on discovering repeated primitive-shaped patterns and evaluating their reuse quality, not resolving runtime execution order or state errors.

What is the best way to audit Reatom dependencies and decide between a local factory and a reatom extension?▼

The best way to audit Reatom dependencies is to detect repeated primitive-shaped patterns and apply a strict decision ladder that evaluates upstream coverage. Compare the findings against core and reatom/reusables coverage to determine whether a local factory or a formal extension is the correct defensible classification.

Does Reatom pattern discovery require evidence-based classification for code refactoring?▼

Reatom pattern discovery requires evidence-based classification for code refactoring, producing a quick triage table and detailed findings with file-path evidence. This ensures every abstraction recommendation is defensible and directly traces back to concrete instances of repeated wiring in the codebase.