ulw-plan

Transform ambiguous engineering requests into decision-complete work plans.

5|Updated May 17, 2026
One-click install
npx skills add https://github.com/islee23520/lfg --skill ulw-plan-islee23520
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ulw-plan
Source: https://github.com/islee23520/lfg/tree/main/skills/ulw-plan
Command: npx skills add https://github.com/islee23520/lfg --skill ulw-plan-islee23520

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill turns ambiguous engineering requests into a decision-complete work plan, so implementation can start without extra interviews or guesswork.

Core Features & Use Cases

  • Explore-first planning: Grounds the request in the codebase, searches for real constraints, and separates discoverable facts from user decisions.
  • Approval-gated planning: Records assumptions, open questions, and scope boundaries before any plan is finalized.
  • Execution-ready output: Produces a structured plan with dependencies, verification steps, and agent-executable acceptance criteria for each task.
  • Use case: A vague request like "make this better" becomes a concrete, reviewable plan for a multi-file refactor or architecture change.

Quick Start

Use the ulw-plan skill to analyze the repository, identify the open decisions, and produce a decision-complete work plan for the requested change.

Frequently Asked Questions about ulw-plan

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

FAQPage Schema
How do I turn a vague codebase change request into an actionable work plan?

To turn a vague codebase change request into an actionable work plan, you need an explore-first approach that grounds the request in the repository, tracks assumptions, and separates discoverable facts from user decisions before finalizing.

What is approval-gated planning for multi-module refactors?

Approval-gated planning for multi-module refactors is a process that records open questions, scope boundaries, and assumptions before finalizing a plan, ensuring implementation starts only after explicit approval and decision completeness.

How do I plan an architecture change that requires codebase exploration first?

Planning an architecture change that requires codebase exploration involves searching for real constraints within the repository first, then producing a structured plan with dependencies and executable verification criteria for each task.

Does this planning approach work for bootstrap planning in an existing codebase?

Yes, this planning approach works for bootstrap planning in an existing codebase by requiring repository grounding to identify real constraints, tracking assumptions, and generating agent-executable acceptance criteria.

What's the best way to ensure a refactor plan is execution-ready for an agent?

The best way to ensure a refactor plan is execution-ready for an agent is to produce a structured plan that includes explicit dependencies, verification steps, and agent-executable acceptance criteria for every task.

When should I not use a decision-complete work plan for an engineering request?

You should not use a decision-complete work plan for an engineering request when the change is trivial, requires no codebase exploration, or lacks the need for approval gating and executable verification criteria.