mino-problem-framing

Original：🇨🇳 Chinese

Translated

This is used when separating technology proposal-first approaches, ambiguous requirements, and inconsistencies in assumptions, meanings, objectives, and success criteria into observations, interpretations, problems, and candidate means, and converting them into Problem Frames and Context Packets by moving between concrete and abstract levels. It is not used for specialized model design, contract extraction, integrated implementation, or mechanical changes that follow approved or frozen baselines.

3installs

Sourcemy-take-dev/inspired-mino-design-skills

Added on2026-08-21

NPX Install

npx skill4agent add my-take-dev/inspired-mino-design-skills mino-problem-framing

SKILL.md Content (Chinese)

View Translation Comparison →

Problem Framing

Before selecting a solution, record whose problem is being addressed, along with its meaning, rationale, and success criteria, accompanied by evidence status. This Skill is read-only and does not finalize models, contracts, architectures, or implementations.

Outcome Contract

The main deliverable is the

Problem Framing Package

. Typically, it returns the following minimum structure, with detailed schemas placed in the workflow reference.

Decision scope, actors, context, observed inhibitors, objectives, losses
Separation of observations, interpretations, assumptions, hypotheses, unknowns, contradictions
Records of technology-influenced candidates saved as unselected
```
candidate_means
```
```
reasoning_trace
```
linking concrete evidence → objectives/losses → success/rejection/validation
Context Packet, AI restatement, success criteria, change boundaries
Selection Gate connecting unresolved choices to candidates, judgment criteria, evidence acquisition methods, and owners

problem_readiness.subject_verdict: ready | conditional | blocked

, required next deliverables, canonical

decision

Validation records including Platform Context and unexecuted items only if platform differences branch problems or evidence

Reference Routing

Internal paths are resolved using the installed
```
skills/
```
directory as the reference root, regardless of deployment location.
First read
```
skills/mino-core/references/core.md
```
and
```
skills/mino-core/references/shared-policies.md
```
; do not redefine common evidence, permissions, routing, or canonical decisions.
For standalone-specific deliverables and judgments, read
```
skills/mino-problem-framing/references/workflow.md
```
.
Only read
```
skills/mino-core/references/requirements-and-traceability.md
```
when normalizing requests passed to subsequent steps.
Only read
```
skills/mino-core/references/domain-discovery.md
```
when discovery of terminology, context, or implicit concepts branches results.
Only read
```
skills/mino-core/references/platform-compatibility.md
```
when filesystem, process, shell, toolchain, test execution, or Windows/Linux/macOS differences relate to evidence; separate platform-specific facts and unexecuted items.
If a standalone request requires multiple specialized deliverables, implementation, or independent validation, hand off to
```
$mino-reproducible-development
```
once.
If a scoped artifact is requested by a router or peer Skill, do not reroute; return only the Problem Framing Package and unresolved obligations to the caller.
When explaining the origin of principles or schemas, treat Context Packet, Selection Gate, and restatement review schema as suite operationalization.

Workflow

Identify items that can be confirmed regarding what will be decided, what will not be decided, actors, owners, reversibility, and change boundaries. Keep unconfirmed items as
```
unknown
```
or
```
contradiction
```
.
Separate observations from interpretations based on the original request, specifications, code, tests, and measurements.
Audit alternative interpretations, identifying evidence, falsification conditions, and impact of errors only for key terms and assumptions that branch results.
Save proposed technologies to
```
candidate_means
```
and describe the problem without technical jargon.
Trace from concrete details to objectives using "in other words", and return from objectives to success/rejection/validation using "for example".
Create a Context Packet and AI restatement, separating statements, comparison bases, proposed statuses, differences, and review subjects.
Determine
```
ready | conditional | blocked
```
, specifying only necessary next deliverables and obligations. Do not create unimplemented artifact IDs.

Platform Compatibility

Do not replace OS names or shells with problem objectives; only place observed platform differences into environment evidence or constraints.
Do not infer the behavior of one platform from another.
If runtime validation is necessary but cannot be performed, leave the runner, command, oracle, and reason for non-execution.

Hard Gates

If any of the following apply, do not proceed to dependent design/implementation; return as

conditional

or

blocked

along with missing evidence and confirmation methods.

Any of the actor, objective, observable inhibitor, or success criteria required for judgment cannot be identified.
The problem cannot be explained without technical jargon.
Key terms/assumptions that branch results lack alternative interpretations, identifying evidence, falsification conditions, or a safe Selection Gate.
It is a one-way analysis that only traces from concrete evidence to objectives or only descends from objectives to validation.
Fabricating existing structural causes for new capabilities, or omitting causal investigation for existing failures.
AI finalizes human-owned values, business meanings, public contracts, or irreversible trade-offs.
Rounding to
```
reversible
```
or a confirmed causal chain without confirming reversibility or the distinction between existing problems/new capabilities.
Marking a problem as
```
ready
```
using only schemas, general theories, person names, or AI self-description.

Completion

The problem, Context Packet, reasoning trace, and AI restatement maintain the same actor, meaning, objective, and change boundary.
Candidate means remain unselected and are comparable in terms of objectives, quality, constraints, and validation.
For new capabilities, handle unmet capabilities; for existing problems, handle causality from symptoms to rules/owners/structural causes with evidence.
Do not hide high-risk unknowns, contradictions, unexecuted platform checks, or human judgments.
Conditional choices are connected to a Selection Gate with candidates, predicates, evidence acquisition, and owners; do not represent
```
pending
```
as selected.
When passing to the next Skill, specify only necessary artifacts and obligations; do not fabricate unimplemented IDs, and judge the current framing artifact with a canonical
```
decision
```
.