From Prompting to System Design: A 10-Stage Model of LLM Users

ChatGPT Use cases and examples
1

The 10-Stage LLM User Maturity Model
Stage 1 — Reactive User

The user immediately asks whatever comes to mind.
The focus is on receiving an answer.
The input is almost unchanged from raw language and has little structure.

Characteristics:

“What is this?”
“Explain this.”
“Summarize this.”

At this stage, the user treats the model similarly to a search engine.

Stage 2 — Request-Oriented User

The user begins to understand the desired output format.
They can request summaries, tables, comparisons, or examples.
However, they still do not directly influence the reasoning structure.

Characteristics:

“Summarize in a table”
“Compare pros and cons”
“Include examples”

This is where output format control begins.

Stage 3 — Constraint-Oriented User

The user can apply constraints such as length, style, scope, and restrictions.
They intuitively understand that poor output is often due to insufficient constraints.

Characteristics:

“Explain simply”
“Avoid technical terms”
“Only give three points”
“Separate assumptions from facts”

At this stage, the input becomes a constrained task rather than a simple question.

Note:
Early stages (1–3) often appear mixed in practice.
A single prompt may contain elements from multiple stages simultaneously.

Stage 4 — Structured User

The user decomposes the question into components.
They separately define goal, scope, constraints, and output format.
They understand that model performance is strongly influenced by input structure.

Characteristics:

Goal / Scope / Constraints / Output
Step-by-step requests
Define first, then compare

This is the practical starting point of prompt engineering.

Stage 5 — Verification-Oriented User

The user does not simply accept answers.
They request separation of facts, assumptions, and uncertainty.
They consider hallucination, inconsistency, and model limitations.

Characteristics:

“Separate evidence from assumptions”
“Only state what is certain”
“Say ‘unknown’ if unsure”
“Check for contradictions with previous answers”

At this stage, the user sees the model as a fallible reasoning system, not just an output generator.

Stage 6 — Framing User

The user applies a specific analytical framework.
They prioritize how the question is processed over what is being asked.

Characteristics:

“Focus on structure before meaning”
“Analyze by cause / effect / impact”
“Organize by pros / cons / risks”
“Break down into structure / flow / importance”

Core idea:
The user defines how to analyze, not just what to ask.

Stage 7 — Loop Design User

The user moves beyond single prompts and creates iterative structures.
They design loops of input → analysis → validation → refinement → feedback.
Output formats are treated as repeatable protocols.

Characteristics:
At this stage, the user treats the model not as a one-time tool,
but as part of a repeatable operational system.

Stage 8 — Meta Design User

The user moves beyond prompts and designs external structures.
They understand that the model is a black box and build meta-layers around it.
At this point, the user becomes closer to a system designer.

Characteristics:

Structural routing
External logging and validation flows

At this stage, the user is no longer just asking questions,
but orchestrating the system externally.

Stage 9 — Engine Orchestration User

Given the constraint that the model itself cannot be modified,
the user operates it as a system by generating, comparing, selecting, and refining multiple responses.
The focus shifts from a single answer to a structured process of candidate generation → evaluation → optimal selection.

Characteristics:

Generate multiple responses and compare them
Select and refine the most appropriate result
Emphasize consistency and reproducibility

At this stage, the model is treated not as a conversational partner,
but as a controllable reasoning engine.

This transition occurs when the goal shifts from producing better answers
to designing systems that consistently produce good outcomes.

Stage 10 — Interaction and Collaboration Design

This is the highest stage.
Here, the focus moves beyond individual prompts to designing how humans and AI collaborate.
It is not about generating answers, but about building continuously improving interaction systems.

Characteristics:

Define roles between the user and the AI
Design collaborative structures
Build iterative and improving workflows
Structure long-term problem-solving processes

2

Phase 1: Message Control Stage

This stage focuses on refining the content and format of a question to obtain better answers.

1 → 2 (Reactive → Request-Oriented)

Required capability: Awareness of output format

Transition condition:
Moving beyond simply asking questions and beginning to specify the desired output format, such as tables, summaries, or comparisons.

2 → 3 (Request-Oriented → Constraint-Oriented)

Required capability: Parameter control and constraint design

Transition condition:
Defining length, level, restrictions, and scope to constrain the response.

Note:
Early stages (1–3) often overlap in practice.
A single prompt may include elements from multiple stages simultaneously.

3 → 4 (Constraint-Oriented → Structured)

Required capability: Question decomposition (Modular Input)

Transition condition:
Breaking the question into structured components such as [Goal / Scope / Constraints / Output].

Phase 2: Reasoning Management Stage

This stage treats the model as a reasoning engine, managing errors and injecting structured thinking patterns.

4 → 5 (Structured → Verification-Oriented)

Required capability: Critical validation and hallucination control

Transition condition:
No longer fully trusting the model and requiring separation of facts, assumptions, and uncertainty.

5 → 6 (Verification-Oriented → Framing)

Required capability: Application of analytical frameworks

Transition condition:
Instead of asking isolated questions, applying a structured framework to guide how the problem is analyzed.

Examples:

“Analyze this in terms of cause / effect / impact”
“Organize by advantages / risks / trade-offs”
“Break this down into structure / flow / importance”
6 → 7 (Framing → Loop Design)

Required capability: Iterative process and feedback design

Transition condition:
Moving beyond one-off prompts to building repeatable workflows:
Input → Process → Validation → Feedback → Iteration

Phase 3: System and Governance Stage

This stage moves beyond individual usage toward system design and operational principles.

7 → 8 (Loop Design → Meta Design)

Required capability: System architecture thinking

Transition condition:
Moving beyond writing prompts to designing external layers that coordinate the model’s reasoning process.

8 → 9 (Meta Design → Engine Orchestration)

Required capability: Quantitative system operation and optimization

Transition condition:
Treating the model not as a conversational partner,
but as a reasoning engine that generates, compares, and selects among multiple outputs.

Operating a structured system:
Candidate generation → Evaluation → Optimal selection

Note:
This transition occurs when the goal shifts from producing better answers
to designing systems that consistently produce good outcomes.

9 → 10 (Orchestration → Interaction and Collaboration Design)

Required capability: Interaction design and collaborative system definition

Transition condition:
Moving beyond obtaining better answers to designing how humans and AI collaborate,
including role distribution and continuously improving workflows for problem-solving.

3

How Do Users Evolve in Prompting?

-– The 10-Stage LLM User Maturity Model

  1. Problem Statement: Is It Skill or Evolution?

Many people use LLMs (Large Language Models), yet the quality of results varies significantly.
This difference is often attributed to “communication skill,” but that is not the core issue.

We should instead ask:

“How do users evolve in their ability to operate an intelligent reasoning engine?”

  1. Limitations of Current Approaches: Tips Without a Model

Most prompt-sharing practices today are fragmented:

Prompting tips
Copyable templates
Model comparisons (benchmarks)

What is missing is a discussion of:

A structured model of user progression

  1. Proposal: A 10-Stage Model of Prompt User Development

This model is not based on knowledge level,
but on the ability to structurally control input.

Phase 1: Message Control Stage

Stage 1 (Reactive)
The user inputs whatever comes to mind and treats the model like a search engine.
Example: “What is this?”

Stage 2 (Request-Oriented)
The user specifies the output format.
Example: “Summarize this in a table”

Stage 3 (Constraint-Oriented)
The user adds constraints and understands that output quality depends on them.
Example: “Explain in simple terms, in three points”

Stage 4 (Structured)
The user breaks the question into components such as
Goal / Scope / Constraints / Output.

Stage 5 (Verification-Oriented)
The user questions the output and asks for separation of
facts, assumptions, and uncertainty.

Note:
Early stages (1–3) often overlap in practice, and a single prompt may include multiple elements simultaneously.

Phase 2: Reasoning System Stage

Stage 6 (Framing)
The user applies a structured analytical framework to guide reasoning.

Examples:

“Analyze in terms of cause / effect / impact”
“Organize by pros / cons / risks”
“Break down into structure / flow / importance”

Core idea:
The user defines how to analyze, not just what to ask.

Stage 7 (Iterative Loop)
The user moves beyond one-off prompts and designs a process:
Input → Processing → Validation → Feedback → Iteration

Stage 8 (Meta Design)
The user designs external layers that coordinate the model’s reasoning process,
treating the model as a black box.

Phase 3: Engine Operation and Governance Stage

Stage 9 (Engine Orchestration)
The user treats the model as a reasoning engine.
They generate multiple responses, compare them, and select the best outcome.

The process becomes:
Candidate generation → Evaluation → Optimal selection

Note:
This transition occurs when the goal shifts from producing better answers
to designing systems that consistently produce good outcomes.

Stage 10 (Interaction and Collaboration Design)
The user designs how humans and AI collaborate.
The focus shifts from generating answers to building structured, continuously improving interaction systems.

  1. Key Insight: Not a Level, but a State

The most important insight of this model is that users are not fixed at a specific stage.

Simple questions → Stage 2
Complex design tasks → Stage 9

In other words:

Users do not stay at a level — they transition between states

Capability Measure

An expert is not someone who always operates at Stage 10,
but someone who can elevate the system to Stage 9–10 when needed.

  1. Example: Evolution of a Diet Question

Stage 1
“Tell me how to diet”
→ Simple information listing

Stage 5
“Separate scientific evidence and uncertainty, and include falsifiable research findings”
→ Verified information

Stage 9
“Generate multiple diet strategies (e.g., low-carb, intermittent fasting),
compare their success likelihood based on my physical condition,
and propose the optimal approach”
→ Structured optimization

  1. Conclusion: Those Who Control Structure Control Intelligence

Prompting is not just a communication skill.

It is a reflection of the user’s ability to design systems.

The key is not what you know,
but how you structure and guide reasoning.

Final Summary

Users do not evolve toward asking better questions.
They evolve toward becoming system designers who control structure.