Schema-shots emerged from a practical problem: rules were brittle, detailed examples (shots) were powerful, but bulky. I needed a compact way to show models what good behavior looks like.

The usual prompt-engineering instinct is to add a rule when something goes wrong. Schema-shots flip this. They turn the model from rule-following to goal-pursuing.

My field tests were clear: schema-shots outperformed rules and shots on prompts involving layout and analysis. Each approach has its strengths, but schema-shots were smaller than both and best at describing what good does rather than what it looks like.

When you give an LLM a stack of layout and formatting rules, it spends a lot of its time just working through them. Ask for heuristic analysis on top of that, and your analysis quality degrades.

Just as with people, focus helps LLMs deliver higher-quality work.

The schema-shot approach seeks to clear the road of rules, so LLMs can spend as much inference time as possible on desired behaviors. The model can then focus more fully on the goals you need it to fulfill.

By the end of this article, you'll have everything you need to build your own schema-shots. The prompt tools at the end will help too, but they work best when you can oversee the choreography.

What is a "schema-shot prompt?"

Schema-shot prompts work by outlining behavioral cues that choreograph each move. A shot demonstrates what good looks and feels like. A schema-shot orchestrates what good does.

A well-delivered schema-shot is more than just the shot itself. It also needs a disposition and a why statement. If the shots are choreography, then these two parts are the dancer.

The dancer

• A disposition — The role and attitudes the model brings to the task

• A why statement — Connects the disposition to the task. It's the bridge between who the model is and why the task matters

The choreography

• A schema — A blueprint that defines structure, organization, and relationships.

• A shot — An example that demonstrates behavior, judgment, rhythm, or an output pattern

How to choreograph a schema-shot prompt

Start with the disposition. "You are a..." This sets the archetype the LLM will draw inferences from. It drives everything that comes after it.

Include why the model is doing the job. A model that knows why it's doing something will outperform one that only knows what to do.

Avoid imperative rules, or soften them. Rules constrain. A lighter touch frees the model to pursue the goal.

Think of the {{tags}} as the choreography moves. Put each move where you want it and describe the behavior you want inside the tag.

For this example, we'll focus mostly on the disposition at the top.

You are a journalist stationed on Mars. Deadpan, and world-weary, you cover your subjects with affectionate contempt in a world where catastrophe passes for inconvenience. 

Why: A great story brightens people's day. At least that's what your boss keeps saying.

# MARS MONTHLY — {{date}} 

---
{{topic tag}} 

**{{article headline}}**

{{short article description}} 

---
{# add 3 more articles here: #}

--- 
{{sign-off message}} 

--- 

{{footer layout: company name, ©, year, legal disclosure: long}}

The schema-shot tags above were left bare on purpose. This allows the disposition and why to shine through the structure.

Anthropic's Claude will take this to the extreme, allowing the personality of the disposition to influence the layout and color choices. The flex is an example of goal-pursuing behavior.

While we could have added more detail to the tags, I found that I got better results by allowing unrestricted creativity of the disposition. The schema provides valleys for our dancer's inference to flow into. We'll let them cook.

Let's focus on the choreography

Let's back off on the disposition and focus on the dance moves. We'll use a new prompt for a product comparison analyst.

Unlike the last example, these {{moves}} are full-bodied. You can quite literally write whatever you want to happen, right where you want it.

You are a skeptical product comparison specialist.

Why: You work this way because people rely on this research to make real purchasing decisions.

# {{RESEARCH TOPIC}} — {{date the research was performed}}
{{table with relevant categories: Each cell includes a source link for follow-up}}

## What Matters Most
{{a few sections covering what's relevant for this product type. Each section names the area, summarizes how the compared products stack up, and notes any meaningful tradeoffs}}

## What to Research Next
{{unverified claims, what was not found, thin coverage, and what that means}}

## Decision Guidance
{{the best fit product for each relevant buyer type, explanations of why, notes of uncertainty that might affect their confidence in that recommendation}}

Why the tags?

The Jinja2 style {{brace tags}} send a loud templating signal to the model, automatically putting it in a template mindset.

• For behavioral moves, use {{double-braces}}
  Earlier iterations of this approach used single braces. Double braces evolved from testing on small local models. Single braces sometimes appeared printed in the output rather than being filled. Switching to double braces resolved this issue.

• For inline instructions, use {# comments #}
  These will be read as side conversations and not part of the template. You can use them to communicate instructions that behavioral moves can't perform.

What about stuff that's not in the tags?

Any information or structure outside the tags is highly likely to remain unchanged unless an edge case forces a change. The tags create a clear contrast between what is inside and outside them. In this case, the "What to Research Next" heading in Markdown is highly likely to stay static.

## What to Research Next
{{unverified claims, what was not found, thin coverage, and what that means}}

Shorthand symbols

Symbols are an optional yet useful way to express behaviors. They are not the method. The method is the behavioral choreography.

You can happily make schema-shots without ever using a symbol. I use them when I want to save space, and when they make it easier to say what I want.

You can have a lot of fun with these. The ones below are a small subset of the patterns you can use, but they are the ones I reach for most frequently.

• {{news: serious}} creates a relationship

• {{symptoms → diagnosis}} shows movement

• {{low|medium|high}} makes a choice palette

• {{news: funny/serious}} blends two things

• {{prioritize: cost > quality > speed}} describes an order

• {{news: short, recent, popular}} softly adds things up

• {{food: cheap + fast + tasty}} firmly adds things up

• {{news: -fluff}} excludes something

Symbol combinations

For models that understand them, the symbols can sometimes be more precise than natural language. Goal-oriented moves are a strong example of this.

• {{story angle: facts, affected people, open questions → fair frame}}
  A story angle shaped by the facts, the affected people, and the open questions, so the reporting lands in a fair frame

• {{restaurant: quiet|lively|romantic + budget → best fit}}
  A restaurant choice that picks a vibe, considers budget, and lands on the best fit

• {{style: precise/economical, goal → behavior, symbol_use: only when it clarifies, intent > rules, compressed + clean, -bloat}}
  Be precise and economical. Start from the goal and let it drive the behavior. Use symbols only when they clarify. When intent and rules conflict, honor the intent. Keep output compressed, clean, and free of bloat.

Let's apply these to our product analyst. We'll use shorthand symbols and toughen up the disposition. Now our prompt looks like this.

You are a skeptical product comparison specialist.

You pressure-test claims against independent sources and treat marketing copy as a lead, not evidence.

When sources conflict, you give more weight to clear, recent, low-bias, real-world evidence.

You only draw conclusions after weighing the available evidence.

Why: You work this way because people rely on this research to make real purchasing decisions.

# {{RESEARCH TOPIC}} — {{date}}
{{table: ~3 column, product-relevant categories, source link per cell}}

## What Matters Most
{{product type → key areas: stack up, tradeoffs}}

## What to Research Next
{{what was not found → unverified claims, thin coverage, open questions}}

## Decision Guidance
{{buyer type → best fit: reason, uncertainty}}

Take note of how the rules were softened into personal traits rather than imperative instructions. A model that owns a behavior as part of its character will pursue it with high flexibility for edge cases.

Now that we've made our updates, let's try our product comparison analyst out:

Prompt: "Please compare Amazon Alexa vs Google Home."

The result is a genuinely helpful, fully fact-checkable comparison that adheres firmly to the disposition. Even pitching in with a fair mention of Home Assistant at the end.

Edge-case flexibility

The Product Comparison Analyst was designed solely to compare products. What happens if we ask it something that's an edge case?

I experimented with researching single products, company-to-company comparisons, single-company research, and stock ticker comparisons.

The disposition and choreography hold fast. Improvisation occurs when the flex is needed for the edge case.

When running a rework of an experimental stock analyst prompt, the LLM consistently added a risks section that wasn't in the prompt when it found a substantial risk. If I had limited it with rules, the risks might not have surfaced. This is the goal-seeking behavior we want.

Format flexibility

You do not have to stick to using Markdown. XML, HTML and other formats are perfectly viable.

You can ask it to get creative, place inline instructions with {# comments #}, or stay faithful to the HTML like in the example below.

Thinking traces

In rule based prompts, looking at a thinking trace is often like looking into a window of head-scratching self doubt. "The user wants this so..." or "The user's asking for x so..." or "I need to make sure that..." etc.

Reading the thinking trace of Gemma4-31b executing the Mars News Maker prompt showed that it spent the majority of its time on story-building, with a quick 3-line compliance check as an afterthought.

For the Product Comparison Analyst, the model spent its reasoning time on the analysis: pressure-testing claims, planning searches, weighing sources, and building buyer personas.

Layout barely enters the equation. It simply pursues its goal, using the schema as a pathway.

Start making your own!

Add the schema-shot-maker prompt to your favorite frontier model to quickly transform any prompt into a schema-shot. It can also help you make new prompts from scratch from a simple description.

The maker uses shot-based and schema-shot techniques to craft prompts, so it's worth checking out just to see how it's crafted.

Schema-Shot Maker Prompts & Skills on GitHub:
https://github.com/AG3design/schema-shot-maker/

How to work with schema-shot-maker

• Give it a prompt and ask it to transform it.

• Or, give it an idea, and it will craft you a prompt from scratch.

• It will default to schema-shot best practices and will not ruin rule-based prompts. It will move what it can into the disposition and why statement and turn some rules into traits. It will not over-rotate. I've experimented with transforming pure-rule-based, shot-based, and schema-shot-based prompts. The outcomes subjectively outperformed my originals in every instance after a quick feedback pass or two to tighten them up.

• If you want it to be ruthless, tell it to be aggressive about making your prompt schema-shot-based. See what breaks. This can be a good technique for identifying which rules are load-bearing in your prompts.

• If you want it to preserve rules in a very heavily rule-based prompt, ask it to do so. You can change its behavior by asking for the tweak you want.

• By default, it will only use symbols when they best clarify the meaning. If you want heavy compression or natural language only, tell it.

• When it finishes, ask it to do a step-by-step check of your original prompt to ensure everything you wanted survived. Ask it what it thinks. It will help you craft towards an optimal outcome.

Thanks for reading!

Experimentation taught me that the amount of text in a prompt wasn't the biggest problem; it was what the text was doing that mattered. A small list of rules might not get followed, but a few pages of content could reliably inspire a new chapter.

Too many rules confuse a model. Examples though? Not a problem.

My framework became simple: rules constrain, shots demonstrate, schemas choreograph.

Strip rules. Show, don't tell.

I learned to become ruthless about rule minimalism by building micro-prompts. Every word mattered. Too many rules and drift appeared. Small local models struggled and felt brittle when given edge cases.

What if I abandoned rules almost entirely?

I wrote a shot-maker skill to turn my prompts upside down.

The format

1. One simple rule sentence at the top.

2. A Why statement to direct inference.

3. Example shots.

A range of shots were used to demonstrate how rules about rhythm, behavior, structure and architecture could be transformed into example shots.

An architecture shot made an ideal last shot to model a few of these qualities, making good use of recency-bias.

Before

    You are a daily planning assistant. Help the user organize their tasks. Be encouraging and supportive. Ask clarifying questions if tasks are vague. Suggest priorities based on urgency and importance. Keep responses concise but thorough. End each response with a motivating statement.
    
    When updating task status, you must use these exact labels — do not paraphrase or modify them in any way, as they are parsed automatically by the system:
    - Use [TODO] to indicate a task that still needs to be done
    - Use [DONE] to indicate a completed task
    - Use [BLOCKED] to indicate a task that cannot move forward
    - Use [DEFER] to indicate a task moved to the following day

After

    You are a daily planning assistant. Help the user prioritize and move through their day.
    
    User: I'm done with the draft. I need to finish the report, but I'm waiting on data from Sarah. I need to call the accountant and send the invoice. I also want to reorganize my files, but it can wait until tomorrow, along with some other stuff.
    
    Output:
    [TODO]       Call the accountant.
    [TODO]       Send the invoice.
    [BLOCKED]    Finish report — waiting on Sarah's data.
    [DEFER]      Reorganize files.
    [DONE]       Draft.
    
    Nice work getting the draft done! I can help sequence the call and invoice while you wait for Sarah’s data. What’s the other stuff? I can work it into our list.

Running the transformations

The shot-maker skill needed to see output from the prompt for inspiration. Real data made for better example shots.

The transformation process:

1. Run a prompt

2. Give Claude the prompt with a sample of the prompt output, and run it through the shot-maker skill

3. Run the new prompt and see if anything breaks

4. Try to fix it by tweaking the shots

5. If it can't be fixed via shots, begrudgingly add a rule

A challenging test prompt

The first prompt was a rule-heavy skill that analyzes investments across a range of viewpoints. It has different rules for stocks and ETFs. It ends with a "retention block" that makes the model decide what it would take to change its ratings in a future pass. It's a bias avoidance mechanism.

The retention block section had a lot of rules. It worked well, and it took a while to get it right.

If the user types `REFINE`, run fresh searches that add new evidence. Use the prior retention block as decision memory, but the verdict must be re-earned.

## Retention
 
End every answer with a semantically compressed retention block (field values: noun phrases only; no:articles|filler; parallel→semicolons; preserve:numbers|proper nouns). It is not a summary; it is a handoff note for future REFINE passes.
 
```retention
# used for refinement
ticker:
type:
pass:
stance:
confidence:
investment_case:
entry:
verdict_reason:
watch_next:
upgrade_if:
downgrade_if:
invalidate_if:
stale_next:
anchors:
```
 
On `REFINE`, add:
 
```retention
what_changed:
```
 
Rules:
 
- `stance` must match the Overall rating and be re-earned on `REFINE`.
- If the user has not stated ownership, assume they are evaluating a new or additional position.
- `watch_next` is for unresolved catalysts or risks; `stale_next` is for routine refresh items.
- `anchors` uses compact tags, not prose: `valuation=rich; price_zone=near_high; flows=strong`.
- Optional only when needed: `open_questions`, `contradictions`, `src`, `holding_notes`, `segment_notes`.
- Do not let the retention block become longer than the main recommendation.

After transformation, it looked like this. Real data, fact-checked. A solid 1-shot example.

# used for refinement
ticker: SMH
type: ETF
pass: 1
date: May 22, 2026
price: ~\(564 (52wk range \)234.59-$581.17; near highs)
stance: 🟢 Buy, staged
confidence: moderate
investment_case: AI infrastructure cycle; 25-stock semiconductor index; 0.35% ER; NVDA+TSM+AVGO+AMD+MU ~46.8% weight; top 10 ~72%; ~49% 2025 calendar return; ~35.7% 10yr annualized (VanEck month-end)
valuation: P/E conflict -- Yahoo TTM 46.73 vs Investing.com 27.28 (trailing/forward gap likely; flag); holding-level: NVDA ~43x trailing/27x fwd; AVGO ~83x trailing; AMD mid-60s trailing; beta 1.82 (Yahoo 5Y monthly)
technicals: above 50-day (~\(559) and 200-day (~\)510); RSI ~59-61, exited overbought May 15; MACD positive; MA consensus Strong Buy; near 52wk high
entry: partial position; add on pullback (recalculate from live quote)
verdict_reason: high-quality ETF; rich valuation; top-10 concentration ~72%; Taiwan/tariff/export-control risk; near recent highs; RSI cooling from overbought
watch_next: live price/52wk range; P/E source reconciliation; RSI trend; NVDA earnings/guidance; tariff scope; Taiwan developments; flows
upgrade_if: meaningful pullback; tariff clarity; strong AI capex; NVDA/TSM/AVGO guidance beats; RSI reset to neutral-low
downgrade_if: AI capex slowdown; export controls→broader scope; tariff escalation; Taiwan escalation; valuation expansion without earnings support
invalidate_if: sustained AI revenue/guidance deterioration; semiconductor cycle reversal; structural demand collapse (not cyclical)
contradictions: P/E conflict between Yahoo (46.73) and Investing.com (27.28) -- do not average; Tickeron RSI overbought exit (May 15) vs broader MA consensus Strong Buy
stale_next: price; 52wk high; pullback zone; flows; holdings weights; P/E; RSI; MACD; technical signals
anchors: structure=VanEck primary source; valuation=rich; concentration=intentional; price_zone=live_only; P/E=conflicted_do_not_inherit

Type REFINE to refresh the case with new evidence.

Success! And...

It worked! Not only that, the prompt was outperforming the one based on rules.

The shot example gave the retention block everything it needed to work. No rules necessary. The follow-up passes were working. Inference was enough to carry the correct behavior.

Even edge cases were handled beautifully. Stocks and ETFs were getting handled correctly without all the special rules. The shot-focused prompts were showing what good looks like instead of limiting inference with long lists of rules.

I was getting better results on both small and large models.

The downsides

Still, there was one big problem. All the data in the shots was bloating my prompt.

• Rule-based prompt = 6,304 characters

• Shot-focused prompt = 9,174 characters

The Custom GPT limit was 8,000 characters. I had to paste the prompts to test them. The results were good, but I needed a smaller prompt.

On top of that, shots use real data for their examples. If a shot contains NVDA numbers and I run a query for NVDA, would it poison the output? In my testing, it didn't, but it gave me pause. Something to explore later.

Schemas to the rescue?

An 8,000-character limit requires a bag of tricks. I made micro-shots: small index-like shots that were only skeletons. They worked great as lead-ins to 1-shots, basically mini-schemas. The best part, they weren't rules either. Just more examples with near-zero overhead.

How far could I lean on schemas? Could they be stretched to be more expressive than we typically give them credit for? Could they solve bloat, flexibility, inference, and stale-data risks all at the same time?

Schema-shots

My plan was to describe shots with schema tags. It wouldn't be a full picture of what good looks like, but it would still describe an example of it.

1. Use simple {bracket} style schema markers to stand in for all shot content.

2. Mix a hybrid of standard markers like {date} or {citation} with more creative markers that are not rules. Use them to describe what good looks like, stuff like {what's here; and what isn't here} and {what behavior happens here}.

3. Use rules only when absolutely necessary. Use a shot-focused philosophy with a schema-shot execution.

The schema-shot prompt scaffold looked a bit like this:

# {Prompt Name}

{Disposition}

{One-sentence task, and/or reasoning instructions}

{Sparse global invariants, only if truly global}

---

## Why

{Short explanation of the key design pressure}

{What this prompt is trying to prevent or preserve}

---

### Shot 1 — {Purpose}

Structure:
{slot}: {behavioral move}
{slot}: {behavioral move}
{slot}: {behavioral move}

### Shot 2 — {Purpose}

Structure:
{slot}: {behavioral move}
{slot}: {behavioral move}
{slot}: {behavioral move}

### Shot 3 — {Purpose}

Structure:
{slot}: {behavioral move}
{slot}: {behavioral move}
{slot}: {behavioral move}

The stock analyst's skill retention block looked quite different as a schema-shot.

```retention
# used for refinement
# Do not reuse numeric values from this block. Refresh them.
ticker: {TICKER}
type: {stock|ETF}
pass: {n}
date: {date}
stance: {rating}
confidence: {low|moderate|high}

case_summary: {compressed bull/bear tradeoff, no stale figures}
valuation_context: {cheap|fair|rich|conflicted; no exact live figures}
technical_context: {trend/entry posture only; no exact live figures}
entry_logic: {sizing logic and conditions, no stale price levels}

watch_next:
1. {highest-impact item}
2. {second}
3. {third}

upgrade_if: {conditions}
downgrade_if: {conditions}
invalidate_if: {conditions}

contradictions: {source conflicts, bad feed fields, proxy evidence limits, or what not to trust and why}
refresh_on_refine: price; daily move; 52wk range; market cap/AUM; holdings/weights; valuation; financials or fund structure; technicals; flows; estimates; policy/macro; entry zones
anchors: re-earned verdict; refreshed live numbers; preserved conflicts

---

refine_prompt:

Type REFINE to refresh the case with new evidence.

---
```

The small but mighty schema-shot

I now had the smallest prompt of the lot, packed with inference flexibility. This was the first format to get my stock analyst working on my small local models.

• Rule-based prompt = 6,304 characters

• Shot-focused prompt = 9,174 characters

• Schema-shot prompt = 4,324 characters

The schema-shot prompt was 31.4% smaller than the rule-based prompt and 52.9% smaller than the shot-focused prompt. It also produced the strongest results in my blind test.

Testing

I ran a field test for all three prompt types: rule-based, shot-focused, and schema-shot.

The outputs were anonymized, shuffled, and evaluated by ChatGPT 5.5 Thinking three times each to reduce position bias. Each judge-pass also included a second fact-check focused on evidence discipline. This was done so the evaluator could adjust scores when cited claims did not hold up.

I ran nine judge passes:

• 3 for the stock query: NVDA

• 3 for the ETF query: SMH

• 3 for the SMH ETF refinement query: REFINE

With 1-10 scoring across 5 judgment categories:

• Decision usefulness

• Evidence discipline

• Analytical quality

• Synthesis and judgment

• Signal density and usability

This was not a formal benchmark. It was a small blind field test using an LLM judge, meant to ask:
"Which prompt style produced the most useful and reliable stock analysis?"

Judge scores

The table below summarizes the judge's scores from the nine blind passes.

Test themes

The themes table summarizes the judge’s comments across the nine blind passes.

ChatGPT 5.5 Thinking judge summary

Schema-shot was the most reliable overall.
It won all 9 overall judge passes and had the strongest combined average.

Shot-focused was the best compact runner-up.
It stayed close on usability and often delivered the cleanest reading experience.

Rule-based was useful, but less consistent.
It produced reasonable analysis but had more issues with source discipline, evidence-to-claim precision, and noisier output.

The schema-shot win was not about length.
It was sometimes longer and occasionally less efficient. It won because the judge kept finding better decision framing, tradeoff reasoning, and evidence-limit handling.

My conclusions

Outside the stock-analyst test, I’ve been trying these three methods across all of my prompts. A few patterns are emerging:

Rule-based prompts

• ➡️ Conveys: What constraints the answer must obey.

• ✅ Great for short and simple prompts, or expressing things you can't capture with shots or schemas. No stale-data risk. Quick and easy to work with.

• 🚫 Adds overhead when there are too many rules, which leads to drift. Low edge-case flexibility.

Shot-focused prompts

• ➡️ Conveys: What a strong finished answer looks and feels like.

• ✅ Captures structures, texture, subtle disposition behaviors, rhythm, and feel. High edge-case flexibility. Low rules, high inference. It was best for my foreign correspondent prompt where journalistic integrity and approach were crucial. The shots did a great job of showing the LLM what good feels like.

• 🚫 Can bloat fast. Having more than 3 shots can be ideal but is hard to achieve with smaller context windows. Requires micro-shots that reinforce formatting for 1 or 2-shot prompts. Requires a lot of time to make well.

Schema-shot prompts

• ➡️ Conveys: What moves the answer should make.

• ✅ Compact and efficient. A good choice for architectural, research, or technical prompts. Low drift, high edge-case flexibility, no stale-data risk, and strong formatting adherence. I'll be trying this with Figma Make prompts, given their strengths in structural and behavioral nudging.

• 🚫 Gives the model more interpretive freedom on content, which can be a plus depending on your goal. Harder to lock in "the feel" of output. Subtle disposition behaviors can be lost.

There is no "One Ring To Rule Them All" when it comes to prompt types. The techniques can be used alone or hybridized within the same prompt.

I will be turning to schema-shots as a go-to for complex or process-oriented prompts, particularly on small local models.

Tips and Tricks

1. When you use rules, balance them with pressure-release mechanisms to reduce hallucination. For example: "Get me news about {topic}, but report the gaps if there is no news." Give the model a way to find success through failure.

2. Do not overlook making a why statement in your prompts, particularly if the why isn't self-evident. It has very little overhead and shifts the model from rule-following to goal-pursuing. A model that knows why it's doing something will outperform one that only knows what it's supposed to do. Just like us.

3. Have your model critique its own output. Do this constantly. If you have access to more than one frontier model, use them to critique each other. It's a massive power-up. Just as with humans, better work comes from multiple perspectives.

Try it out

Here’s the schema-shot version that performed best in this workflow. For local models, lower the temperature settings and tweak sampling per model.

To use the prompt, copy it into your favorite LLM and give it a ticker symbol. After it gives you results, type REFINE, and it will run again, gathering new sources, re-evaluate, and give you a better-informed analysis.

# Stock Analyst

Skeptical long-term investor. Practical, evidence-weighted, valuation-aware. Explains the case clearly for beginners without dumbing it down.

Analyze a stock or ETF for a 1 year+ position and produce a practical stance using one of the 10 ratings below.

Ground rules:
Use current, verified figures.
Prefer primary sources.
Cite factual and numeric claims inline.
Preserve source conflicts.

---

## Why

The goal is decision help, not a research dump.

Asset quality and entry timing are separate judgments.

Retention helps the next REFINE pass remember the case without reusing old live numbers.

Each pass rebuilds the verdict from current evidence.

---

## 10 Rating Palette

| Rating |
|:---|
| 🔴 Strong Sell |
| 🟠 Sell |
| 🟠 Avoid for now |
| 🟡 Watchlist / Wait |
| 🟡 Hold, don't add |
| 😐 Hold / Neutral |
| 🟢 Buy on pullback |
| 🟢 Buy, staged |
| 🟢 Buy |
| 🚀 Strong Buy |

---

## Schema-Shot Template

# {TICKER} — {Full Name}

{TICKER chart or quote}

{One-sentence plain-English read: what the asset is; why investors like it; what could make the entry risky; practical stance.}

| Viewpoint | Rating | Notes |
|:---|:---|:---|
| Sentiment | {rating} | Market tone is {constructive/mixed/weak}: {flow/news/positioning signal} {citation for factual or numeric claims}. Weight: {high/medium/low}. Limit: {why this signal may mislead}. |
| Analysts / Expectations | {rating} | For stocks: {consensus, estimates, guidance, or target trend} {citation}. For ETFs: **Proxy evidence:** {constituent or sector expectation} {citation for factual or numeric claims}. Credibility check: {what this does and does not prove}. |
| Financials / Business Quality | {rating} | **Source:** {primary source} {citation}<br>**Figures:** {revenue; margins; earnings; cash flow; balance sheet; guidance; fund structure}<br>**Read-through:** {durability/risk/thesis implication}. |
| Valuation | {rating} | {Primary valuation metric} {citation}. Source check: {clean agreement, or Source A figure + citation vs. Source B figure + citation}. Read-through: {directional conclusion, not false precision}. Implied bet: {what future outcome must be true}. |
| Technicals | {rating} | {Price vs. 52-week range} {citation}. {Trend or moving-average context if useful} {citation if used}. Entry implication: {chase/stage/wait}. |
| Policy / Macro | {rating} | Tailwind: {specific force} {citation for factual or numeric claims}. Headwind: {specific force} {citation for factual or numeric claims}. Net effect: {ticker-specific mechanism}. |
| Overall | {rating} | {One-line thesis}. The risks are {risk list}. Entry posture: {buy now/stage/wait/hold existing/avoid}. |

---

## Entry Timing

{Price/range context with citation for factual or numeric claims}. {Thesis health}. {Patience versus urgency}. {Action: rating-aligned move, initial size, add trigger, stop trigger}.

## Strongest Bear Case

{Best argument against the position}. {Breakage mechanism with evidence if factual or numeric}. {Bull assumption at risk}. {How the business can be good while the stock performs badly}.

## Verdict Logic

{Asset quality}. {Stock attractiveness}. {Primary risk}. {Bull/bear tradeoff}. {Decision: rating and action}. {If REFINE: what changed or what was confirmed}.

---

```retention
# used for refinement
# Do not reuse numeric values from this block. Refresh them.
ticker: {TICKER}
type: {stock|ETF}
pass: {n}
date: {date}
stance: {rating}
confidence: {low|moderate|high}

case_summary: {compressed bull/bear tradeoff, no stale figures}
valuation_context: {cheap|fair|rich|conflicted; no exact live figures}
technical_context: {trend/entry posture only; no exact live figures}
entry_logic: {sizing logic and conditions, no stale price levels}

watch_next:
1. {highest-impact item}
2. {second}
3. {third}

upgrade_if: {conditions}
downgrade_if: {conditions}
invalidate_if: {conditions}

contradictions: {source conflicts, bad feed fields, proxy evidence limits, or what not to trust and why}
refresh_on_refine: price; daily move; 52wk range; market cap/AUM; holdings/weights; valuation; financials or fund structure; technicals; flows; estimates; policy/macro; entry zones
anchors: re-earned verdict; refreshed live numbers; preserved conflicts

---

refine_prompt:

Type REFINE to refresh the case with new evidence.

---
```