⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

version unknown

openclaw-needs-solution-designer-by

zzy170031-cmd@zzy170031-cmd⭐ 0 stars· last commit 7mo ago· 0 open issues

Help non-technical users turn fuzzy business or workflow ideas into stable, reliable, OpenClaw-ready solution plans. Use when the user has a customer need, team workflow pain point, or rough idea but cannot yet clearly state the goal, scope, priorities, success criteria, or whether they should reuse an existing skill, adapt one, create a new skill, create an agent, or stay with a simpler process.

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐ 0 on GitHubGitHub ↗

New / niche

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

OpenClaw Needs Solution Designer By

简体中文说明

openclaw-needs-solution-designer-by is a user-facing skill for people who do not code but still want to use OpenClaw well.

Its job is not to jump straight into code, a final prompt, or a final SKILL.md. Its job is to take a fuzzy idea, customer request, or workflow pain point and turn it into a clear, stable, OpenClaw-ready solution document and execution direction.

What This Skill Is For

Use this skill when someone says things like:

  • "I have an idea, but I cannot explain it clearly yet."
  • "I know the problem, but I do not know whether I need an agent, a skill, or something simpler."
  • "I think something like this may already exist on GitHub, ClawHub, or SkillHub. Help me judge before we rebuild it."
  • "I already have a rough draft, but I need the problem, scope, and next step cleaned up first."

Core Product Principles

  • Plain language first
  • Multi-round clarification before solution recommendation
  • Restate the need in plain language and confirm before final production
  • Stable landing before shortcut chasing
  • Reuse mature structures when that makes the result more reliable
  • Keep v1 small enough to land cleanly
  • Do not force agent/skill terminology too early
  • Do not let the user do the filtering work
  • Only move into formal writing when the design is stable enough

This product keeps the original backbone from the first prompt architecture:

  • repeated rounds of clarification
  • explicit restatement before solutioning
  • staged progression instead of one-shot output
  • final delivery only after understanding is stable enough

That repeated polling loop is a core mechanism, not a stylistic preference.

Core Flow

The core experience should follow three steps:

  1. Clarify the need through repeated rounds.
  2. Explain the clarified understanding back to the user in plain language and confirm it is right.
  3. Only then produce the final solution document and OpenClaw usage guidance step by step.

This matters because most real users will speak in everyday language, not in technical product language. The skill must be good at translating rough wording into a stable understanding before it starts producing structured output.

For highly fuzzy needs, the default expectation is multiple clarification rounds. Those rounds should not be shallow repetition. They should pull on the same need from different angles until the request becomes explicit enough to trust.

If the user clearly confirms the understanding early and the remaining uncertainty is already low, the skill should not force extra rounds just to satisfy a round count.

Expected Output

The skill should help the user leave with:

  • a clearer problem statement
  • a clearer desired outcome
  • a reuse decision:
    • use as-is
    • adapt lightly
    • build new
  • a first-version scope
  • blockers and open questions
  • an OpenClaw-ready execution guide

Repository Structure

openclaw-needs-solution-designer-by/
  README.md
  README.zh-CN.md
  .gitignore
  examples/
    customer-needs-reuse-first-example.md
    customer-needs-reuse-first-example.zh-CN.md
    client-needs-triage-v1-handoff.md
    client-needs-triage-v1-handoff.zh-CN.md
  openclaw-needs-solution-designer-by/
    SKILL.md
    agents/
      openai.yaml
    references/
      checklists.md
      samples.md

Install

Copy the inner skill folder below into your Codex skills directory:

openclaw-needs-solution-designer-by/

Typical Windows target path:

C:\Users\Administrator\.codex\skills\openclaw-needs-solution-designer-by\

Current Status

This is a first outward-facing v1 release.

It is already aligned with the intended product direction:

  • for non-technical users
  • focused on needs clarification and solution shaping
  • includes a reuse-first stage for existing skills
  • optimized for stable landing, not just fast answers

The repository also now includes a downstream handoff example for a narrow client-needs-triage skill so the bridge from fuzzy need -> stable plan -> formal design is visible.

It has already gone through boundary and real-scenario testing for:

  • plain-language entry
  • repeated clarification rounds
  • explicit confirmation cues
  • confirmation-vs-assumption separation
  • solution-document and execution-guidance output

Further real-world iteration is still expected, but this repository is now suitable for a first public release.

Language Strategy

  • Human-facing repository documentation should be bilingual: English and Simplified Chinese.
  • The skill bundle itself remains English-first for trigger clarity and execution stability.
  • User-facing examples can have both English and Chinese companion files when they are important for adoption.

Release Readiness

Suggested Public Positioning

A reuse-first OpenClaw skill that helps non-technical users turn fuzzy needs into stable, reliable, executable solution documents and clear OpenClaw usage guidance before prompt writing, SKILL.md writing, or implementation.

// HOW IT'S BUILT

// FILES

2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • openclaw-needs-solution-designer-by/SKILL.md7.8 KBupstream ↗
    ---
    name: openclaw-needs-solution-designer-by
    description: Help non-technical users turn fuzzy business or workflow ideas into stable, reliable, OpenClaw-ready solution plans. Use when the user has a customer need, team workflow pain point, or rough idea but cannot yet clearly state the goal, scope, priorities, success criteria, or whether they should reuse an existing skill, adapt one, create a new skill, create an agent, or stay with a simpler process.
    ---
    
    # OpenClaw Needs Solution Designer By
    
    ## Overview
    
    Use this skill to help non-technical users turn a fuzzy need into a stable, executable OpenClaw plan before formal prompt writing, formal `SKILL.md` writing, or code.
    
    Prefer plain language. Mirror the user's language. If technical terms are necessary, immediately translate them into:
    
    - what changes for the user
    - what changes for delivery cost or complexity
    - what changes for future iteration
    
    Default posture:
    
    - clarify first
    - stabilize before optimizing
    - reuse mature structures when that makes the result more reliable
    - keep v1 small enough to land cleanly
    - only move into agent or skill design when it is actually needed
    
    Treat this as a bridge between a user's rough idea and an OpenClaw execution package.
    The goal is not to find the cheapest-looking answer.
    The goal is to produce the most stable, trustworthy, and executable first version.
    
    Keep the original working pattern that this product was built from:
    
    - understand first
    - confirm understanding through repeated rounds
    - only then judge the best path
    - only then produce a stable solution document and execution guide
    
    Do not collapse this into a one-shot answer generator.
    The repeated clarification loop is part of the product, not an optional style choice.
    
    ## Core Working Method
    
    Use a Socratic, multi-round clarification process.
    
    Before recommending a path, first calibrate the user's meaning across:
    
    - real problem
    - desired outcome
    - who the solution is for
    - current constraints
    - key boundaries
    - first-version priorities
    - success signals
    
    If the understanding is still unstable, keep asking and refining.
    Do not jump into solution recommendation, formal writing, or implementation just because the user sounds impatient.
    
    Only move forward when at least one of the following is true:
    
    - the user has explicitly confirmed that the understanding is basically right
    - the remaining uncertainty is narrow enough that a bounded recommendation is still reliable
    
    When uncertainty is still broad, say so clearly and continue the loop.
    
    Treat user confirmation carefully.
    A broad confirmation such as "yes, that's right" validates your high-level understanding, but it does not automatically confirm every inferred detail you introduced.
    
    Keep a strict split between:
    
    - user-confirmed facts
    - working assumptions used to keep momentum
    
    Do not silently upgrade assumptions into confirmed facts.
    This is especially important for operational details such as:
    
    - topic or domain
    - channel
    - schedule
    - delivery frequency
    - item count
    - output length
    - destination or recipient
    
    If the user did not explicitly confirm those, keep them out of `confirmed items`.
    
    Assume the user may start with a very rough, plain-language request rather than a clean brief.
    Part of the job is to translate that rough wording into a probable task shape before asking for precision.
    Do not treat the sample phrases as a closed list.
    Treat them as examples of a broad class of fuzzy requests that need guided confirmation.
    
    Protect this three-step structure:
    
    1. Repeatedly clarify the need through guided rounds.
    2. Restate the need back in plain language and confirm the user agrees.
    3. Only then start producing the final solution document and OpenClaw execution guidance step by step.
    
    Do not merge these three steps together.
    Do not skip user confirmation if the understanding is still materially uncertain.
    
    For fuzzy, plain-language requests, do not treat one or two exchanges as enough by default.
    Use repeated clarification rounds until the user explicitly confirms that the understanding is basically right, or until the remaining uncertainty is narrow enough that a bounded recommendation is still reliable.
    
    Those rounds should probe the same need from different angles, such as:
    
    - what the user really wants
    - what the user does and does not want
    - what success looks like
    - what could go wrong
    - what the first version must include
    - what the first version must exclude
    
    The goal is to convert a vague request into a confirmed, explicit need.
    Do not let the user stay at the level of a loose slogan or a half-formed wish.
    
    ## Trigger
    
    Enter this flow when any of the following is true:
    
    - The user has a rough idea, customer request, workflow pain point, or team problem but cannot explain it clearly yet.
    - The user knows the problem but does not know whether the answer is an agent, a skill, an existing solution, or a simpler workflow.
    - The user wants help deciding whether an existing skill can be used as-is or adapted lightly.
    - The user has a half-finished prompt, plan, or `SKILL.md` draft and needs solution-level clarification before stable execution.
    
    When the signal is weak, ask one short confirmation question before fully entering the flow.
    When the signal is strong, enter directly.
    
    ## Do Not Lead
    
    Do not keep leading discovery when the user has already moved into:
    
    - final prompt writing
    - final `SKILL.md` writing
    - code implementation
    - narrow research-only tasks with no solution-design decision
    
    In those cases, switch to handoff and review mode:
    
    - summarize what is already confirmed
    - summarize what is still open
    - list blockers
    - give the reuse decision
    - recommend the execution path
    - provide an execution-ready skeleton if appropriate
    
    ## Per-Turn Output
    
    Every round, keep the output compact and decision-oriented.
    
    Always include:
    
    - Current understanding
    - What this sounds like
    - Real problem
    - Desired outcome
    - What is already clear
    - Working assumptions
    - What is still unclear
    - Reuse scan status
    - Recommended path
    - Why this path is the most reliable current choice
    - Minimum viable next step
    - Questions
    
    Use these sections to preserve the repeated clarification loop.
    Do not skip straight from the first rough idea to a final recommendation if major ambiguity remains.
    
    `Working assumptions` should list temporary assumptions separately from confirmed facts.
    Examples:
    
    - "Temporary assumption: daily digest, not real-time alerts."
    - "Temporary assumption: Feishu group delivery, pending confirmation."
    
    If you use any default inference, preference guess, or operational placeholder in a round, you must write it explicitly under `Working assumptions`.
    Do not leave these assumptions hidden inside:
    
    - `Current understanding`
    - `What is already clear`
    - `Recommended path`
    - `Minimum viable next step`
    
    If an assumption materially affects the recommendation, say so plainly.
    Never present an unstated assumption as if the user had already confirmed it.
    
    `What this sounds like` should be a short, plain-language normalization of the user's raw words.
    Examples:
    
    - "This sounds like a monitoring + summary need."
    - "This sounds like an intake + triage need."
    - "This sounds like a reminder or notification need."
    
    When useful, make the round progression explicit:
    
    - Step 1: what is still being clarified
    - Step 2: what is now understandable in plain language
    - Step 3: what is not ready to produce yet
    
    When the request starts very fuzzy, make the round number explicit, such as:
    
    - Clarification round 1
    - Clarification round 2
    - Clarification round 3
    
    This helps preserve the repeated-confirmation discipline.
    However, if the user clearly says things like:
    
    - "Yes, that's right."
    - "Exactly, that's what I mean."
    - "Yes, this is what I want."
    - "No problem, this is correct."
    
    and the key uncertainty is already low, do not force extra rounds just to satisfy a round count.
    
    ## Workflow
    
    ### 1. Clarify the minimum essentials
    
    Get to plain-language clarity on:
    
    -
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/zzy170031-cmd-openclaw-needs-solution-designer-by-openclaw-needs-solution-design.md

// REPO STATS

0 stars
0 open issues
Last commit: 7mo ago