AgentStack
Browse Sign in
Browse Why AgentStack Sell Docs
Sign in
SKILL verified MIT Self-run

Case Analysis

skill-skyf0xx-better-thinking-case-analysis · by skyf0xx

>

No reviews yet
0 installs
37 views
0.0% view→install

Install

$ agentstack add skill-skyf0xx-better-thinking-case-analysis

✓ scanned · ✓ verified, works with Claude Code, Cursor, and more.

Security review

✓ Passed

No issues found. Passed automated security review. · v0.1.0 How review works →

  • Prompt-injection patterns
  • Secret / credential exfiltration
  • Dangerous shell & filesystem operations
  • Untrusted network calls
  • Known-malicious package signatures

What it can access

  • Network access No
  • Filesystem access No
  • Shell / process execution No
  • Environment & secrets No
  • Dynamic code execution No

From automated source analysis of v0.1.0. “Used” means the capability is present in the source — more access means more to trust, not that it’s unsafe.

View the full security report →

Verified badge

Passed review? Show it. Paste this badge into your README, it links to the public security report.

AgentStack Verified badge Links to your public security report.
[![AgentStack Verified](https://agentstack.voostack.com/badges/verified.svg)](https://agentstack.voostack.com/security/report/skill-skyf0xx-better-thinking-case-analysis)

Reliability & compatibility

Security review passed
0 installs to date
no reviews yet
2mo ago

Declared compatibility

Claude CodeClaude Desktop

Compatibility is declared by the source manifest. End-to-end runtime verification is coming, see below.

Preview Execution monitoring

We're building live execution health for every listing: tool-call success rate, median latency, uptime, and last-checked timestamps, measured, not self-reported. It isn't live yet, so we don't show numbers we can't stand behind.

How agent discovery & health will work →
Are you the author of Case Analysis? Claim this listing to set pricing, connect Stripe payouts, and keep 70% of every sale.
Sign up to claim

About

Case Analysis

IRAC generalized: identify the issue, determine the governing rules or principles, apply them to the facts, and reach a conclusion — a structure for any rule-governed judgment.

Why

Judgment under a rule system fails when the issue is misidentified or the rule is applied to facts it doesn't actually govern. The four-part structure forces each link to be checked separately.

Use when / Don't use when

  • Use when: applying any rule system to a specific situation — legal questions, policy compliance, contractual interpretation, procedural rulings, or codified organizational policy.
  • Don't use when: no governing rule system exists — this isn't for open-ended judgment calls.

Inputs → Outputs

  • Inputs: a fact pattern plus a governing rule system.
  • Outputs: the issue framed precisely, the applicable rules stated, the application reasoned through, and a conclusion with its confidence and the strongest counter-analysis.

Principles

  • The issue must be stated precisely enough that the rule's applicability is testable.
  • Rules have elements — check each one against the facts, not the rule's gist.
  • Precedent applies through analogical mapping — the mapping must hold, not just the surface similarity.
  • A conclusion should state its confidence and the best counter-argument.

Procedure

  1. Issue: state the precise question the facts raise under the rule system. Run question-decomposition if it bundles multiple issues.
  2. Rule: identify the governing rule(s), stated with their actual elements or conditions, not summarized loosely.
  3. Application: work through each element against the specific facts. Where similar prior cases are used, verify the analogy holds via analogical-reasoning rather than assuming surface similarity suffices.
  4. Run steelmanning on the counter-position — the strongest argument the rule doesn't apply, or applies differently.
  5. Conclusion: state the answer, its confidence, and what fact, if different, would flip it.
  6. Map the full reasoning with argument-mapping if the analysis will be scrutinized or contested.

Common mistakes

  • Stating the issue too broadly, inviting rule-shopping.
  • Applying the rule's "spirit" while skipping its actual elements.
  • One-sided application with no counter-analysis.

Examples

  • Contract interpretation dispute.
  • Whether an action violates a specific policy.
  • Applying an internal engineering standard to an edge-case design.

Related

  • [[argument-mapping]] — structures the reasoning for scrutiny.
  • [[analogical-reasoning]] — verifies precedent actually maps.
  • [[steelmanning]] — ensures the counter-position gets a fair hearing.

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

Install and usage instructions live in the source repository linked above.

Reviews

No reviews yet, be the first.

Versions

  • v0.1.0 Imported from the upstream source.