⏳ This skill is pending AI review.
Scores will appear once the review pipeline completes.
openclaw-needs-solution-designer-by
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.
// RATINGS
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:
- Clarify the need through repeated rounds.
- Explain the clarified understanding back to the user in plain language and confirm it is right.
- 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
- License: MIT
- Publish checklist: publish-checklist.md
- Roadmap: ROADMAP.md
- Usage guide: HOW-TO-USE.md
- Main public docs:
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