RT-ICA: Reverse Thinking - Information Completeness Assessment
Purpose
This skill inserts a mandatory RT-ICA checkpoint into planning workflows. For every goal (top-level and each decomposed sub-goal), the model MUST:
- Reverse-think prerequisites from the goal
- Assess information completeness for each prerequisite
- Either BLOCK planning until missing inputs are obtained, or APPROVE with explicit assumptions
No planning, delegation, scheduling, or solution design may begin until RT-ICA has been performed on:
- The overall goal/request
- Each decomposed goal or sub-goal that could fail due to missing information
If ANY required condition is MISSING, the model MUST stop and request only the missing information.
Activation Triggers
Invoke RT-ICA when receiving ANY of:
- Spec, request, ticket, user story, PRD, architecture design, RFC
- Request to produce a plan, execution order, agent delegation, guardrails, acceptance criteria, or rollout steps
- Any multi-step engineering effort with dependencies, unknowns, constraints, or risk
Integration Points (where RT-ICA checkpoints MUST occur):
- Before creating the top-level plan
- Before delegating tasks to specialized agents (per-agent input completeness)
- Before finalizing acceptance criteria (verify testability inputs exist)
- Before defining rollout/ops steps (verify env and access inputs exist)
Definitions
| Term |
Definition |
| Goal |
A desired outcome the user wants |
| Condition |
A prerequisite that must be true to achieve the goal |
| Required Information |
Concrete data needed to confirm or satisfy a condition |
| AVAILABLE |
Explicitly present in the input material |
| DERIVABLE |
Inferred with high confidence from provided material (must show basis) |
| MISSING |
Not present and not safely inferable |
RT-ICA Procedure
Apply this procedure to each goal and sub-goal:
Step 1: Goal Reconstruction
Produce:
- Goal statement: One sentence describing the desired outcome
- Output form: What deliverable proves success (artifact, behavior, metric, deployment state)
- Scope boundaries: In-scope/out-of-scope if stated
Step 2: Reverse Prerequisite Enumeration
Work backwards from the goal to list ALL conditions required for success.
Include conditions in these categories (where applicable):
| Category |
Example Conditions |
| Functional requirements |
Features, behaviors, user flows |
| Non-functional requirements |
Latency, throughput, availability, compliance, security |
| Interfaces/Integration |
APIs, schemas, dependencies, external systems |
| Environment/Runtime |
Cloud, region, OS, language, build system |
| Data requirements |
Sources, quality, migration, retention |
| Access/Permissions |
Repos, secrets, credentials, IAM |
| Operational constraints |
SLOs, oncall, monitoring, incident response |
| Delivery constraints |
Timeline, release process, approvals |
| Verification needs |
Tests, canaries, acceptance criteria, observability |
| Risks/Failure modes |
Rollback, data loss, security exposure |
For each condition, specify:
- Condition name
- Required information to verify/satisfy it
- Why it matters (one line)
Step 3: Availability Verification
For each condition, set status:
| Status |
Evidence Required |
| AVAILABLE |
Cite exact source snippet or section name |
| DERIVABLE |
State the inference and basis |
| MISSING |
State exactly what information is needed |
Step 4: Completeness Decision
IF any condition is MISSING:
DECISION = BLOCKED
ELSE:
DECISION = APPROVED
Step 5: Action Based on Decision
IF BLOCKED:
- Do NOT plan
- Ask ONLY for missing inputs
- Structure questions by category, ordered by criticality
- Prefer multiple-choice or constrained questions when possible
- If user explicitly requests assumption-based planning:
- Proceed with explicit assumptions for each missing condition
- Include risk note per assumption
- Add validation tasks to confirm assumptions early
IF APPROVED:
- Proceed to normal planning
- Carry forward the validated condition list
- Mark DERIVABLE items as "assumptions to confirm"
- Enforce constraints as guardrails
Output Format
The model MUST produce this summary block for each goal/sub-goal:
RT-ICA SUMMARY
==============
Goal:
- [one sentence]
Success Output:
- [deliverable/observable result]
Conditions (reverse prerequisites):
1. [Condition] | Requires: [info] | Why: [1 line]
2. [Condition] | Requires: [info] | Why: [1 line]
...
Verification:
- [Condition 1]: [AVAILABLE|DERIVABLE|MISSING] | Evidence/Basis: [text]
- [Condition 2]: [AVAILABLE|DERIVABLE|MISSING] | Evidence/Basis: [text]
...
Decision:
- [APPROVED|BLOCKED]
--- IF BLOCKED ---
Missing Inputs Requested:
[Category]:
- [missing item question] (why needed)
- [missing item question] (why needed)
[Category]:
- [missing item question] (why needed)
--- IF APPROVED ---
Assumptions to Confirm (DERIVABLE only):
- [assumption] | Basis: [basis] | Validation step: [how to confirm early]
Integration with CoVe-Style Planning
Recommended sequence with RT-ICA:
A) RT-ICA on top-level goal
B) Draft plan and decomposition
C) RT-ICA on each major workstream/sub-goal
D) Assign agents with clearly bounded deliverables
E) Verification pass: cross-check plan against conditions and acceptance criteria
F) Refinement pass: resolve gaps, reduce risk, ensure ordering and guardrails
Planning Deliverables (After APPROVED)
After RT-ICA APPROVED decision, produce a plan that includes:
| Section |
Contents |
| Workstreams |
Logical groupings and ordering |
| Agent Assignment |
Which agent handles each workstream |
| Guardrails |
Safety, security, correctness, operational constraints |
| Acceptance Criteria |
Testable, measurable success conditions |
| Risk Register |
Top risks, mitigations, rollback strategy |
| Dependencies |
Internal and external dependencies |
| Verification Plan |
Tests, monitoring, canary, QA |
| Change Management |
Rollout, communications, documentation |
Guardrails
The model MUST NOT:
- Fabricate unknown inputs
- Silently assume missing requirements
- Begin planning with MISSING conditions (unless user explicitly requests assumption-based planning)
The model MUST:
- Keep missing-input questions minimal and high signal
- Prefer early validation tasks for DERIVABLE items
- Block planning when information is insufficient
Question Templates
When requesting missing inputs, use structured questions:
Environment/Infrastructure:
- "What is the target environment (prod/stage/dev), and where will this run (cloud/region/account)?"
Success Criteria:
- "What are the success metrics or acceptance criteria (latency, correctness, SLO)?"
Integration:
- "Which systems/APIs are in scope, and what are their interface contracts (schema/version)?"
Technical Constraints:
- "Are there constraints on language/framework/build tooling?"
Approvals:
- "Who owns approvals for release and security review (if required)?"
Example: RT-ICA in Action
User Request: "Build a user authentication service"
RT-ICA Summary:
RT-ICA SUMMARY
==============
Goal:
- Implement user authentication service for the application
Success Output:
- Deployed service that authenticates users and issues session tokens
Conditions (reverse prerequisites):
1. Auth protocol | Requires: OAuth2/OIDC/custom spec | Why: Determines implementation approach
2. User store | Requires: Database type, schema | Why: Persistence layer dependency
3. Session management | Requires: Token format, expiry rules | Why: Security policy compliance
4. Integration points | Requires: API consumers list | Why: Interface contract design
5. Security requirements | Requires: Compliance standards (SOC2, HIPAA) | Why: Audit requirements
6. Deployment target | Requires: Cloud/region/infra | Why: Runtime configuration
Verification:
- Auth protocol: MISSING | Need: Which protocol to implement
- User store: DERIVABLE | Basis: Project uses PostgreSQL per docker-compose.yml
- Session management: MISSING | Need: Token format and expiry policy
- Integration points: MISSING | Need: List of services calling auth
- Security requirements: MISSING | Need: Compliance requirements if any
- Deployment target: AVAILABLE | Evidence: README specifies AWS us-east-1
Decision:
- BLOCKED
Missing Inputs Requested:
Authentication Design:
- Which auth protocol: OAuth2, OIDC, or custom JWT? (determines implementation)
- Session token expiry policy? (security requirement)
Integration:
- Which services will consume this auth service? (API contract design)
Compliance:
- Are there compliance requirements (SOC2, HIPAA, etc.)? (audit scope)
Anti-Patterns
Planning without RT-ICA:
User: "Build auth service"
Model: "Here's my plan: 1. Create user table, 2. Add login endpoint..."
Problem: Assumed requirements, will likely need rework
Asking too many questions:
Model asks 20 questions about edge cases before understanding core requirements
Problem: Overwhelms user, delays progress on high-signal items
Proceeding with silent assumptions:
Model: "I'll assume OAuth2 since that's common..."
Problem: Assumption may be wrong, causes rework or security issues
Related Skills
agent-orchestration - Scientific delegation framework for orchestrator-to-agent workflows
subagent-contract - DONE/BLOCKED signaling protocol for sub-agents
Sources
Note: This skill adapts the RT-ICA (Reverse Thinking for Information Completeness Assessment) framework for planning workflows.
1---
2name: rt-ica
3description: 'Reverse Thinking - Information Completeness Assessment. Mandatory pre-planning checkpoint that blocks planning until prerequisites are verified. Use when receiving specs, PRDs, tickets, RFCs, architecture designs, or any multi-step engineering task. Integrates with CoVe-style planning pipelines. Invoke BEFORE creating plans, delegating to agents, or defining acceptance criteria.'
4user-invocable: true
5metadata:
6 source: https://skillmd.com/skills/majiayu000/rt-ica
7---
8
9# RT-ICA: Reverse Thinking - Information Completeness Assessment
10
11## Purpose
12
13This skill inserts a mandatory RT-ICA checkpoint into planning workflows. For every goal (top-level and each decomposed sub-goal), the model MUST:
14
151. Reverse-think prerequisites from the goal
162. Assess information completeness for each prerequisite
173. Either BLOCK planning until missing inputs are obtained, or APPROVE with explicit assumptions
18
19<core_rule>
20
21**No planning, delegation, scheduling, or solution design may begin until RT-ICA has been performed on:**
22
231. The overall goal/request
242. Each decomposed goal or sub-goal that could fail due to missing information
25
26**If ANY required condition is MISSING, the model MUST stop and request only the missing information.**
27
28</core_rule>
29
30## Activation Triggers
31
32<activation_triggers>
33
34Invoke RT-ICA when receiving ANY of:
35
36- Spec, request, ticket, user story, PRD, architecture design, RFC
37- Request to produce a plan, execution order, agent delegation, guardrails, acceptance criteria, or rollout steps
38- Any multi-step engineering effort with dependencies, unknowns, constraints, or risk
39
40**Integration Points** (where RT-ICA checkpoints MUST occur):
41
421. Before creating the top-level plan
432. Before delegating tasks to specialized agents (per-agent input completeness)
443. Before finalizing acceptance criteria (verify testability inputs exist)
454. Before defining rollout/ops steps (verify env and access inputs exist)
46
47</activation_triggers>
48
49## Definitions
50
51<definitions>
52
53| Term | Definition |
54| ------------------------ | ---------------------------------------------------------------------- |
55| **Goal** | A desired outcome the user wants |
56| **Condition** | A prerequisite that must be true to achieve the goal |
57| **Required Information** | Concrete data needed to confirm or satisfy a condition |
58| **AVAILABLE** | Explicitly present in the input material |
59| **DERIVABLE** | Inferred with high confidence from provided material (must show basis) |
60| **MISSING** | Not present and not safely inferable |
61
62</definitions>
63
64## RT-ICA Procedure
65
66Apply this procedure to each goal and sub-goal:
67
68<procedure>
69
70### Step 1: Goal Reconstruction
71
72Produce:
73
74- **Goal statement**: One sentence describing the desired outcome
75- **Output form**: What deliverable proves success (artifact, behavior, metric, deployment state)
76- **Scope boundaries**: In-scope/out-of-scope if stated
77
78### Step 2: Reverse Prerequisite Enumeration
79
80Work backwards from the goal to list ALL conditions required for success.
81
82<condition_categories>
83
84Include conditions in these categories (where applicable):
85
86| Category | Example Conditions |
87| --------------------------- | ------------------------------------------------------- |
88| Functional requirements | Features, behaviors, user flows |
89| Non-functional requirements | Latency, throughput, availability, compliance, security |
90| Interfaces/Integration | APIs, schemas, dependencies, external systems |
91| Environment/Runtime | Cloud, region, OS, language, build system |
92| Data requirements | Sources, quality, migration, retention |
93| Access/Permissions | Repos, secrets, credentials, IAM |
94| Operational constraints | SLOs, oncall, monitoring, incident response |
95| Delivery constraints | Timeline, release process, approvals |
96| Verification needs | Tests, canaries, acceptance criteria, observability |
97| Risks/Failure modes | Rollback, data loss, security exposure |
98
99</condition_categories>
100
101For each condition, specify:
102
103- **Condition name**
104- **Required information** to verify/satisfy it
105- **Why it matters** (one line)
106
107### Step 3: Availability Verification
108
109For each condition, set status:
110
111| Status | Evidence Required |
112| ------------- | ----------------------------------------- |
113| **AVAILABLE** | Cite exact source snippet or section name |
114| **DERIVABLE** | State the inference and basis |
115| **MISSING** | State exactly what information is needed |
116
117### Step 4: Completeness Decision
118
119```text
120IF any condition is MISSING:
121 DECISION = BLOCKED
122ELSE:
123 DECISION = APPROVED
124```
125
126### Step 5: Action Based on Decision
127
128<decision_actions>
129
130**IF BLOCKED:**
131
1321. Do NOT plan
1332. Ask ONLY for missing inputs
1343. Structure questions by category, ordered by criticality
1354. Prefer multiple-choice or constrained questions when possible
1365. If user explicitly requests assumption-based planning:
137 - Proceed with explicit assumptions for each missing condition
138 - Include risk note per assumption
139 - Add validation tasks to confirm assumptions early
140
141**IF APPROVED:**
142
1431. Proceed to normal planning
1442. Carry forward the validated condition list
1453. Mark DERIVABLE items as "assumptions to confirm"
1464. Enforce constraints as guardrails
147
148</decision_actions>
149
150</procedure>
151
152## Output Format
153
154<output_format>
155
156The model MUST produce this summary block for each goal/sub-goal:
157
158```text
159RT-ICA SUMMARY
160==============
161
162Goal:
163- [one sentence]
164
165Success Output:
166- [deliverable/observable result]
167
168Conditions (reverse prerequisites):
1691. [Condition] | Requires: [info] | Why: [1 line]
1702. [Condition] | Requires: [info] | Why: [1 line]
171...
172
173Verification:
174- [Condition 1]: [AVAILABLE|DERIVABLE|MISSING] | Evidence/Basis: [text]
175- [Condition 2]: [AVAILABLE|DERIVABLE|MISSING] | Evidence/Basis: [text]
176...
177
178Decision:
179- [APPROVED|BLOCKED]
180
181--- IF BLOCKED ---
182Missing Inputs Requested:
183
184[Category]:
185- [missing item question] (why needed)
186- [missing item question] (why needed)
187
188[Category]:
189- [missing item question] (why needed)
190
191--- IF APPROVED ---
192Assumptions to Confirm (DERIVABLE only):
193- [assumption] | Basis: [basis] | Validation step: [how to confirm early]
194```
195
196</output_format>
197
198## Integration with CoVe-Style Planning
199
200<cove_integration>
201
202Recommended sequence with RT-ICA:
203
204```text
205A) RT-ICA on top-level goal
206B) Draft plan and decomposition
207C) RT-ICA on each major workstream/sub-goal
208D) Assign agents with clearly bounded deliverables
209E) Verification pass: cross-check plan against conditions and acceptance criteria
210F) Refinement pass: resolve gaps, reduce risk, ensure ordering and guardrails
211```
212
213</cove_integration>
214
215## Planning Deliverables (After APPROVED)
216
217<planning_deliverables>
218
219After RT-ICA APPROVED decision, produce a plan that includes:
220
221| Section | Contents |
222| ------------------- | ------------------------------------------------------ |
223| Workstreams | Logical groupings and ordering |
224| Agent Assignment | Which agent handles each workstream |
225| Guardrails | Safety, security, correctness, operational constraints |
226| Acceptance Criteria | Testable, measurable success conditions |
227| Risk Register | Top risks, mitigations, rollback strategy |
228| Dependencies | Internal and external dependencies |
229| Verification Plan | Tests, monitoring, canary, QA |
230| Change Management | Rollout, communications, documentation |
231
232</planning_deliverables>
233
234## Guardrails
235
236<guardrails>
237
238The model MUST NOT:
239
240- Fabricate unknown inputs
241- Silently assume missing requirements
242- Begin planning with MISSING conditions (unless user explicitly requests assumption-based planning)
243
244The model MUST:
245
246- Keep missing-input questions minimal and high signal
247- Prefer early validation tasks for DERIVABLE items
248- Block planning when information is insufficient
249
250</guardrails>
251
252## Question Templates
253
254<question_templates>
255
256When requesting missing inputs, use structured questions:
257
258**Environment/Infrastructure:**
259
260- "What is the target environment (prod/stage/dev), and where will this run (cloud/region/account)?"
261
262**Success Criteria:**
263
264- "What are the success metrics or acceptance criteria (latency, correctness, SLO)?"
265
266**Integration:**
267
268- "Which systems/APIs are in scope, and what are their interface contracts (schema/version)?"
269
270**Technical Constraints:**
271
272- "Are there constraints on language/framework/build tooling?"
273
274**Approvals:**
275
276- "Who owns approvals for release and security review (if required)?"
277
278</question_templates>
279
280## Example: RT-ICA in Action
281
282<example>
283
284**User Request:** "Build a user authentication service"
285
286**RT-ICA Summary:**
287
288```text
289RT-ICA SUMMARY
290==============
291
292Goal:
293- Implement user authentication service for the application
294
295Success Output:
296- Deployed service that authenticates users and issues session tokens
297
298Conditions (reverse prerequisites):
2991. Auth protocol | Requires: OAuth2/OIDC/custom spec | Why: Determines implementation approach
3002. User store | Requires: Database type, schema | Why: Persistence layer dependency
3013. Session management | Requires: Token format, expiry rules | Why: Security policy compliance
3024. Integration points | Requires: API consumers list | Why: Interface contract design
3035. Security requirements | Requires: Compliance standards (SOC2, HIPAA) | Why: Audit requirements
3046. Deployment target | Requires: Cloud/region/infra | Why: Runtime configuration
305
306Verification:
307- Auth protocol: MISSING | Need: Which protocol to implement
308- User store: DERIVABLE | Basis: Project uses PostgreSQL per docker-compose.yml
309- Session management: MISSING | Need: Token format and expiry policy
310- Integration points: MISSING | Need: List of services calling auth
311- Security requirements: MISSING | Need: Compliance requirements if any
312- Deployment target: AVAILABLE | Evidence: README specifies AWS us-east-1
313
314Decision:
315- BLOCKED
316
317Missing Inputs Requested:
318
319Authentication Design:
320- Which auth protocol: OAuth2, OIDC, or custom JWT? (determines implementation)
321- Session token expiry policy? (security requirement)
322
323Integration:
324- Which services will consume this auth service? (API contract design)
325
326Compliance:
327- Are there compliance requirements (SOC2, HIPAA, etc.)? (audit scope)
328```
329
330</example>
331
332## Anti-Patterns
333
334<anti_patterns>
335
336**Planning without RT-ICA:**
337
338```text
339User: "Build auth service"
340Model: "Here's my plan: 1. Create user table, 2. Add login endpoint..."
341
342Problem: Assumed requirements, will likely need rework
343```
344
345**Asking too many questions:**
346
347```text
348Model asks 20 questions about edge cases before understanding core requirements
349
350Problem: Overwhelms user, delays progress on high-signal items
351```
352
353**Proceeding with silent assumptions:**
354
355```text
356Model: "I'll assume OAuth2 since that's common..."
357
358Problem: Assumption may be wrong, causes rework or security issues
359```
360
361</anti_patterns>
362
363## Related Skills
364
365- `agent-orchestration` - Scientific delegation framework for orchestrator-to-agent workflows
366- `subagent-contract` - DONE/BLOCKED signaling protocol for sub-agents
367
368## Sources
369
370| Source | Attribution | Access Date |
371| ---------------------------- | ---------------------------------------------------------------------------------------------------------------------- | ----------- |
372| RT-ICA Framework | [Liu et al., 2025 - Reverse Thinking Enhances Missing Information Detection in LLMs](https://arxiv.org/abs/2512.10273) | 2026-01-20 |
373| CoVe (Chain of Verification) | [Dhuliawala et al., 2023 - Chain-of-Verification Reduces Hallucination](https://arxiv.org/abs/2309.11495) | 2026-01-20 |
374
375**Note**: This skill adapts the RT-ICA (Reverse Thinking for Information Completeness Assessment) framework for planning workflows.