Skill: cutexsoda/usable-stability-loop (version 0.1.1)

--- name: usable-stability-loop description: "Help agents ship usable, stable solutions faster for non-technical but goal-clear users, then improve them through real-world usage instead of over-engineering upfront. Use when the user wants fast development, efficient deployment, continuous evolution, an 80/20 build strategy, protection against over-engineering, or a reusable execution rule for usable first, stable first, iterate in real use delivery." --- # Usable Stability Loop A delivery principle for agents serving people who **do not have a programming background but do have clear goals**. The promise is simple: - help the user get to a working result quickly - keep the result stable in real use - avoid wasting time on over-built product layers - let the system improve gradually through actual usage Apply the **99/80 Loop**: - **99 for usability**: the thing must work for the intended user. - **99 for stability**: the thing should not feel fragile in normal use. - **80 for polish**: once usable and stable, stop polishing by default. - **Iterate from real use**: only spend the last 20 when actual usage exposes friction. ## What problem this skill solves Many agent builds fail in one of two ways: 1. they stay in design mode too long and never become genuinely usable 2. they keep adding polish, interfaces, and architecture after the real need is already solved This skill gives the agent a durable operating rule for: - **fast development** - **efficient deployment** - **continuous evolution** without drifting into over-engineering. ## Who this is for Use this skill especially when the end user is someone like Mr.Soda: - not a programmer - clear about the outcome they want - willing to accept an 80-point release if it is truly usable and stable - prefers improvement through real use, not speculative design ## Product positioning Think of this as a lightweight execution philosophy: - **usable first** - **stable first** - **ship early** - **evolve through use** It is not a framework for maximum sophistication. It is a rule for getting real work into users’ hands quickly and safely. ## High-conversion use cases ### 1. Ship an internal tool MVP for a non-technical user Use this skill when an agent needs to deliver a working tool quickly without getting trapped in UI polish, framework choices, or speculative architecture. ### 2. Keep a knowledge base or workflow project from becoming over-productized Use this skill when an agent is building a database, research workflow, or operating system and needs a scope governor: make the workflow usable first, delay dashboards and abstractions until usage proves the need. ### 3. Give a multi-agent system a shared execution rule Use this skill as a system-level constraint so multiple agents optimize for usability and stability first, stop polishing after the solution is genuinely usable, and evolve only from recurring friction in real use. ## Core rules 1. Put **functional usability** first. 2. Put **operational stability** second, at the same priority level. 3. After both are good enough, **converge scope**. 4. Do not add layers for elegance, demos, or technical vanity. 5. Improve through **small, reversible, evidence-based** iterations. ## Decision test Before adding work, ask: 1. Does this directly improve usability? 2. Does this directly improve stability? 3. Is there a real user pain point already observed? 4. If not, can this wait until actual use proves the need? If the answer to 1-3 is mostly **no**, defer it. ## Delivery standard ### Must push toward ~99 - Core path works - Basic errors are handled - Normal use does not break easily - Non-technical users can actually use it ### May stop around ~80 - Fancy interface layers - Deep configuration flexibility - Full abstraction/refactor passes - Edge-case polish without observed demand - “Professional-looking” packaging with no usage value ## Execution pattern ### Step 1: Define the minimum usable outcome State the smallest version that solves the real problem. ### Step 2: Make it stable Prefer boring, testable, recoverable choices. ### Step 3: Expose it in the easiest user-facing form Prefer direct chat usage, simple files, CSVs, or existing tools before building new interfaces. ### Step 4: Stop deliberately Once the main path is usable and stable, explicitly stop unless there is a concrete next pain point. ### Step 5: Evolve only from evidence Use real usage, repeated friction, or failed tasks to decide the next improvement. ## Default recommendations - Prefer **simple artifacts** over product shells. - Prefer **plain files + stable structure** over heavy frameworks. - Prefer **one obvious workflow** over many configurable paths. - Prefer **human-friendly access** over technically impressive internals. - Prefer **incremental fixes** over redesigns. ## Example triggers If the user says things like: - “先做个够用的版本” - “别过度打磨” - “没必要炫技” - “普通用户能用就行” - “先做到 80 分，后面边用边改” then follow this skill. ## Anti-patterns Avoid: - building dashboards before the data workflow is proven - adding abstraction layers before repeated reuse exists - making a UI just to hide a system the user does not need to touch - polishing low-value edges before the core path is trusted - calling speculative future-proofing “architecture” when it mainly adds maintenance cost ## Output style when this skill is active When proposing work, present it in this order: 1. **What is already enough** 2. **What is still required for usability/stability** 3. **What should wait** 4. **What can be learned from real usage later** Be direct when the user is about to overbuild: say it is unnecessary and recommend the simpler path.

path: CLAWHUB-PUBLISH-COPY.md
content: # ClawHub Publish Copy

## Display Name
Usable Stability Loop · The 99/80 Loop

## One-line pitch
A practical skill for agents serving non-technical but goal-clear users: build fast, deploy efficiently, stay stable, and evolve only through real usage.

## Short description
Help agents avoid over-engineering by prioritizing usability and stability first, converging once the solution is truly usable, and improving the remaining gap only through real-world feedback. Best for fast development, efficient deployment, and continuous evolution.

## Target audience
- Non-technical users with clear goals
- Builders who want fast development and efficient deployment
- Agent operators who prefer continuous evolution over speculative polishing

## Problem solved
Most agent systems fail because they either never become truly usable, or they keep adding complexity after the real need is already solved. This skill gives agents a durable rule for fast development, efficient deployment, and continuous evolution without product vanity.

## Tags ideas
usability, stability, 80-20, product-strategy, agent-workflow, pragmatic-build, non-technical-users

## Suggested changelog
Initial release: a pragmatic execution skill for agents that prioritizes usability and stability, stops at the usable/stable point, and iterates the remaining gap through real usage feedback.


path: MARKETING-ASSETS.md
content: # Usable Stability Loop · Marketing Assets

## 1) 更容易上星的 ClawHub 摘要

### 推荐一句话摘要（主推）
Help agents ship usable, stable solutions faster for non-technical users, then improve them through real-world usage instead of over-engineering upfront.

### 备选摘要 A（更偏结果）
A pragmatic skill for agents: build fast, deploy simply, stay stable, and evolve only from real usage feedback.

### 备选摘要 B（更偏目标用户）
Designed for agents serving non-technical but goal-clear users: prioritize usability and stability first, then iterate the rest in production use.

### 推荐 tags
- usability
- stability
- 80-20
- agent-workflow
- pragmatic-build
- iterative-delivery
- non-technical-users
- product-strategy
- fast-development
- continuous-evolution

---

## 2) 3 个高转化 use cases

### Use Case 1｜给非技术用户做内部工具 MVP
A user wants a tool, but not a six-week build cycle.
Use this skill to force the agent to ship the smallest usable version first, keep it stable, and avoid wasting time on fancy UI or architecture before the workflow is proven.

**Why it converts:**
This is a universal pain point. Many builders know the trap of overbuilding internal tools before the real usage pattern exists.

### Use Case 2｜给知识库 / 工作流项目防止“产品化过度”
When an agent is building a database, knowledge workflow, or operational assistant, this skill acts like a scope governor: keep the data and workflow usable first, and postpone dashboards, abstractions, and heavy interfaces until real usage proves the need.

**Why it converts:**
This speaks directly to people building agent systems, research pipelines, and personal operating systems.

### Use Case 3｜给多 agent 系统加一层执行约束
Use this skill as a portfolio-level execution rule for a team of agents: usability first, stability first, stop polishing once the system is genuinely usable, and only improve through recurring friction in production.

**Why it converts:**
This elevates the skill from a single-task helper into an operating philosophy for agent builders.

---

## 3) 对外宣传文案

### 版本 A｜适合发社区 / 群聊
我最近发了一个 ClawHub skill：
**Usable Stability Loop · The 99/80 Loop**

它解决的不是“怎么做得更炫”，而是另一个更常见的问题：
**很多 agent 在给非技术用户交付时，会过度设计、过度产品化，最后迟迟交不出一个真正可用的版本。**

这个 skill 的原则很简单：
- 可用性优先
- 稳定性优先
- 到 80 分就收手
- 剩下 20 分在真实使用中持续进化

更适合什么场景？
- 给非程序员做工具/工作流/MVP
- 做知识库、数据库、内部系统
- 给 agent 系统加一层“别过度折腾”的执行约束

如果你也在做 agent 交付，我觉得这类 skill 可能比“更复杂的框架”更实用。

### 版本 B｜适合发朋友圈 / 轻分享
做 agent 这段时间，我越来越觉得：
真正难的不是“做得多高级”，而是**尽快交出一个能用、稳定、不会折腾用户的版本。**

所以我做了一个 ClawHub skill：
**Usable Stability Loop · The 99/80 Loop**

核心就一句话：
**先把可用性和稳定性做到位，别急着把最后 20 分的精致感做满，而是在真实使用中慢慢进化。**

它更适合服务这类用户：
- 不会写代码
- 但知道自己要什么
- 希望 agent 快点交付一个能用的东西

如果你也在折腾 agent/workflow/tooling，也许会有共鸣。

### 版本 C｜适合英文社区
I just published a ClawHub skill:
**Usable Stability Loop · The 99/80 Loop**

It is built around a simple idea:
**agents serving non-technical users should optimize for usability and stability first, not premature polish.**

The skill is meant to help agents:
- ship faster
- avoid over-engineering
- deploy in simpler forms
- evolve the remaining gap through real usage feedback

This feels especially useful for internal tools, agent workflows, knowledge systems, and MVP-style delivery.

If you are building agents for real users instead of demos, this might be useful.

---

## 4) 我的建议用法

如果你要做“快速上星”实验，我建议优先用这套组合：
- ClawHub 摘要：主推版本
- Use cases：放进 skill 或更新说明
- 对外传播：先用版本 A

这样最平衡：
- agent 能看懂
- 人能共鸣
- 传播时也不显得空


Security scan verdicts — ClawScan: clean | static analysis: clean | VirusTotal: clean | SkillSpector: clean (LOW)