dxrefine

Decomposes large engineering tasks into estimated sub-tickets aligned with existing architecture.

3|2|Updated Jan 25, 2026
One-click install
npx skills add https://github.com/mitchellfyi/dex --skill dxrefine
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: dxrefine
Source: https://github.com/mitchellfyi/dex/tree/main/skills/dxrefine
Command: npx skills add https://github.com/mitchellfyi/dex --skill dxrefine

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill eliminates the ambiguity and risk of tackling large, unstructured engineering tasks by providing a structured, architecture-aligned refinement process that clarifies scope, identifies risks, and breaks work into actionable, estimated sub-tickets before any implementation begins.

Core Features & Use Cases

  • Architecture-aligned scoping: Maps work to your project's existing C4 architecture, identifies impacted components, and flags drift against current architecture documentation.
  • Design pattern surfacing: Identifies applicable design patterns for each sub-ticket, reusing existing patterns in your codebase to avoid unnecessary reinvention.
  • Risk and edge case identification: Surfaces cross-component risks, edge cases, and non-functional requirements early, reducing rework during implementation.
  • Use Case: For a large feature like adding user account export, use this skill to break it into sub-tickets for API endpoint creation, data serialization, UI export button, and end-to-end verification, each with clear scope, size estimate, and domain ownership.

Quick Start

Use the dxrefine skill to refine your engineering task description into a structured plan with estimated, shippable sub-tickets aligned to your project's architecture.

Frequently Asked Questions about dxrefine

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

FAQPage Schema
How do I break down a large engineering task into estimated sub-tickets?

To break down large engineering tasks into estimated sub-tickets, you refine unstructured work into independently shippable units aligned with your project's existing architecture. This process maps work to components, identifies risks, and assigns clear domain ownership.

What is architecture-aligned scoping for technical refinement?

Architecture-aligned scoping is a refinement process mapping unstructured engineering tasks to your project's existing C4 architecture. It identifies impacted components, flags documentation drift, and surfaces applicable design patterns before implementation begins.

How do I identify cross-component risks and edge cases before implementation?

You identify cross-component risks and edge cases by applying a structured technical refinement process to feature work and system changes. This surfaces non-functional requirements and potential drift early, reducing rework during implementation.

When do I need design pattern surfacing for sub-ticket decomposition?

You need design pattern surfacing when decomposing complex features or bug fixes requiring cross-component alignment. It identifies applicable design patterns for each sub-ticket, reusing existing codebase patterns to avoid unnecessary reinvention.

Can I use this refinement approach for both feature work and bug fixes?

Yes, you can use this technical refinement approach for feature work, bug fixes, and system changes. It decomposes any large, unstructured engineering task into scoped sub-tickets that respect project constraints and assign clear domain ownership.

What's the best way to scope engineering plans that respect project constraints?

The best way to scope engineering plans respecting project constraints is to decompose tasks into estimated, independently shippable sub-tickets. This method clarifies scope, surfaces edge cases, and aligns work with your current architecture documentation.