Skip to content

Composite scoring: break complex judgments into atomic scores and weight them ​

The previous lesson's smart routing used a single Score to rate complexity, answering the question "is this answer safe to execute automatically." This lesson answers a different question: a batch of items is in front of you, and you need to pick the best X according to several criteria—resume screening, ticket triage, and search re-ranking all fall into this category.

The official docs give it a name: Composite scoring. The approach in one sentence: break a complex judgment into independent dimensions, score each dimension with its own Score, then merge them with weights you control in code. The case on the official patterns page is engineering resume screening: 4 dimensions, one request, two sets of weights, two ranking lists. The whole thing takes 10 minutes.

In fact, you've already written its minimal version: in the Score lesson, step 5 used three questions to compute a ticket priority of 0.66. This lesson expands that three-line weighted formula into a full ranking system—multiple candidates, multiple roles, plus a debugging method for "what to do when rankings look wrong."

What you'll be able to do after this lesson ​

  • Use Jev composite scoring to break apart multi-dimensional judgments like "is this candidate good": one atomic Score per dimension across four dimensions, with independent scores fetched in parallel in a single request
  • Write the normalized weighted merging code: each question is divided by its highest level number to pull it into 0–1, then summed by weight—the official scoring.py works as-is
  • Serve two roles from the same batch of atomic scores: Senior IC weights 0.40/0.10/0.40/0.10, Engineering Manager weights 0.15/0.40/0.20/0.25—one scoring run produces two rankings
  • When rankings look wrong, change only the weight constants and recompute locally—don't touch the scales or the prompt; to add a dimension, add one question to the question dictionary, and the number of requests per candidate stays the same
  • Clearly explain the division of labor between composite scoring and last lesson's gating: gating decides "is it safe to use," composite scoring decides "how to rank"

Your current predicament ​

  • I asked an LLM to screen resumes, with a prompt saying "please score 1–10 based on technical depth, team leadership, architecture, and breadth." It returned an essay plus a 7.5; rerunning next month it became 8.2—no distribution, no justification. When the hiring manager asked "how was this 7.5 calculated," all I could do was read the essay aloud
  • When the ranking is wrong, the only option is to edit the prompt: add a line of "value architecture skills more," rerun all 200 resumes, and the rankings of the technical-depth cohort get thrown into chaos. I can't tell whether the wording made the difference or the model was just in a different state this time
  • A Senior IC role and an Engineering Manager role call for two different kinds of people, so I wrote two prompts and ran each once—the same candidate differs by a dozen-plus places between the two rankings, and the two sets of scores aren't comparable at all

When to use this technique ​

When you need to:

  • Rank a batch of items by multiple criteria and take the top X: resume screening, ticket priority, content quality grading, search result re-ranking
  • Ranking criteria change often, or different roles and scenarios each have their own emphasis: change the weights to change the ranking, no need to resend requests
  • A total score that can be broken down and explained: how many points per dimension, how much each weight contributes—all laid out in code

And you don't want to:

  • Parse the LLM's "overall score" text output and write a pile of fallback code for format drift
  • Edit the prompt and rerun everything each time a criterion changes, with results that aren't reproducible
  • Run the model once per role for the same batch of candidates

🎒 Prerequisites ​

  • Have read Efficient workflows: four architectural patterns and know where composite scoring sits among the four official patterns (benefits noted: cost, reliability, speed)
  • Can write Score questions: this entire lesson builds on it—how to write scales and why scores can land between two levels were covered in steps 1 and 3 of that lesson; the three-question priority example in step 5 is the minimal version of this lesson
  • Have gotten the first request working: .venv has typesafe-sdk installed, and TYPESAFE_API_KEY is in the environment variables
  • Remember the conclusion of parallel questions: multiple questions evaluate the same state in parallel and independently, and adding questions barely increases response time (this lesson's 4 questions fetched in one request relies on exactly that)

Core idea ​

Split first, merge after. The official definition of composite scoring, verbatim:

Break a complex judgment into atomic scores, combine with weights you control in code. (Break a complex judgment into atomic scores and merge them with weights you control in code.)

When will you use it? The official framing: we often need to rank a batch of items by several criteria. Composite scoring is the simplest decomposition of that task—break the judgment into independent dimensions, score each dimension separately, and merge with weights in code.

The official patterns page uses resume screening as a full demonstration (engineering hiring, ultimately taking the top X for manual review), and the whole pipeline looks like this:

text
candidate resume
   │  One request: resume + 4 Score questions
   ▼
┌──────────────────────────────────────┐
│ python_depth    (Python depth)       │ ← 4 questions evaluated in parallel, independently
│ team_leadership (team leadership)    │
│ system_design   (system design)     │
│ generalist      (generalist breadth) │
└──────────────────────────────────────┘
   │  One response: atomic scores of 4 questions on a 0–4 scale
   ▼
Normalize to 0–1 (each question ÷ 4, done in your code)
   ├─ Senior IC weights: 40% Python + 10% team leadership + 40% design + 10% generalist → ic_score
   └─ EM weights:      15% Python + 40% team leadership + 20% design + 25% generalist → em_score
   ▼
Rank by total score, take the top X for each role

Why not use one big question to ask the LLM "how good is this person overall"?

Dimension comparedLLM prompt holistic scoringJev composite scoring
Return formatA short essay with a 7.5 in it, format unpredictableOne typed score per dimension (0–4) + probabilities + confidence
Multiple criteriaAll crammed into one holistic scoreOne question and one independent score per criterion
Adjusting ranking criteriaReword the prompt, rerun everything, not reproducibleChange the weight constants in code, recompute instantly
Multi-role rankingA separate prompt per role, run everything againSame batch of atomic scores, new ranking just by changing weights
Explainability"The model thinks it's good"Per-dimension scores + weights, all visible in code

The official how-to manual lists "decomposing questions" as the most important concept in the entire guide: broad questions hide several judgments behind a single answer; atomic questions expose the judgments so you can inspect, tune, and combine them in code (docs/concepts/how-to-build-with-system-one.md:108).

Relation to the previous two lessons: parallel questions is the transport layer—4 questions come back in one request; the gate of smart routing answers "is this answer safe to use"; composite scoring answers "how do I rank this batch of things". In the official patterns table its benefit is labeled Cost, Reliability, Speed—the only one of the four patterns that covers all three (docs/patterns.md:19).

Follow along ​

Step 1: Break "good candidate" into four atomic Score questions ​

Why: "Is this candidate good" is several judgments stacked together: Python fundamentals, team leadership, system design, breadth of exposure. Crammed into one question, you can't tell which dimension dragged the score down, and you can't tune just one dimension. Splitting them apart is the prerequisite for everything that follows.

These are the four question definitions given in the official pattern page's Playground (extracted from the rendered page; instructions and criteria are the official original text):

python
from typesafe_sdk import Score

RESUME_QUESTIONS = {
    "python_depth": Score(
        instructions="How much depth of python experience does this candidate have, based on the supplied resume?",
        criteria=[
            "No Python experience mentioned",
            "Mentioned but no detail",
            "Used in projects, some specifics",
            "Primary language, multiple projects",
            "Deep expertise: architecture, performance, libraries",
        ],
    ),
    "team_leadership": Score(
        instructions="How much experience does this candidate have managing or leading engineering teams?",
        criteria=[
            "No management experience mentioned",
            "Informal mentorship or tech lead role",
            "Led a small team or project",
            "Managed a team with direct reports",
            "Managed multiple teams or an engineering org",
        ],
    ),
    "system_design": Score(
        instructions="How much experience does this candidate have designing large-scale or distributed systems?",
        criteria=[
            "No architecture work mentioned",
            "Contributed to design discussions",
            "Designed components of a larger system",
            "Owned architecture of a significant system",
            "Designed systems at scale across multiple domains",
        ],
    ),
    "generalist": Score(
        instructions="How much evidence is there that this candidate picks up unfamiliar tools, roles, or domains outside their core specialty?",
        criteria=[
            "Only one domain or role mentioned",
            "Some variety but within a narrow field",
            "Worked across a few different areas or tech stacks",
            "Regularly moved between domains, wore many hats",
            "Track record of ramping up in unfamiliar areas and delivering",
        ],
    ),
}

Three details:

  • One dimension per question. "One question testing several things" is a pitfall called out in the Score lesson: once level descriptions are written as "punctual, smart, experienced", an input that's high on one item and low on another has nowhere to land—confidence drops and the score's meaning gets muddy. Four questions split cleanly, each handling only one thing
  • Each level is a situation, not a degree. "Primary language, multiple projects" can be checked against a resume; "fairly good grasp" cannot—the model only matches descriptions against the state; it can't see level numbers or neighbors. The Score lesson ran an experiment: a pure numeric scale produced confidence 0.33, while a situational-description scale produced 1.0
  • Number of levels = the number of tiers you can describe clearly. The official version uses 5 levels per question here; the Score lesson's principle is to use as many levels as you can clearly describe, at most 10, and 3 is fine too—don't add levels you can't describe clearly

You should see: four Score questions in RESUME_QUESTIONS, each testing only one dimension, each with a 5-level situational scale—Python depth, team leadership, system design, generalist, none mixing with the others. Question IDs (python_depth and the like) are names you choose yourself; they aren't sent to the model, and answers come back under the same IDs.

  • Each of my questions tests only one dimension, and every level is a checkable situational description

Step 2: Fetch all four atomic scores in parallel with one request ​

Why: The four dimensions don't depend on each other—as the previous lesson covered, independent questions should be merged into one request: parallel evaluation adds almost no response time and costs only a few extra question tokens. Four questions split apart without paying for four requests—that's where composite scoring's "cost" benefit comes from.

Create resume_screen.py, hook up the question definitions from Step 1, and send a resume to try it:

python
from typesafe_sdk import TypeSafeClient

# RESUME_QUESTIONS 的定义见第 1 步,此处省略

resume = """
Jane Doe — Backend Engineer, 8 years
- Primary language Python; built and own the retry and backoff layer
  of a 40-node distributed ingestion pipeline (2M events/day)
- Tech lead of a 4-person payments squad for 2 years; no direct reports
- Contributed to architecture reviews across the org
- Backend infrastructure only; one year on an internal CLI tool
"""

with TypeSafeClient() as client:
    response = client.system_one(
        state=resume,
        questions=RESUME_QUESTIONS,
    )

for qid in ["python_depth", "team_leadership", "system_design", "generalist"]:
    answer = response.answers[qid]
    print(qid, answer.score, answer.confidence)

Run it:

bash
.venv/bin/python resume_screen.py

(The official Playground example only includes 4 questions and provides no resume state; this resume text is a test input written for this lesson.)

You should see: four numbers between 0–4, each with a confidence in 0–1. Reading against this self-written resume: Python is the primary language across multiple projects → python_depth on the high side; tech lead but no direct reports → team_leadership lands in the middle; only participated in architecture discussions → system_design low-middle; almost exclusively backend → generalist on the low side. Scores can land between two levels (e.g. 1.5)—it's the probability-weighted average position; the verification method is in Step 3 of the Score lesson. Go by the actual values in your response; they may change with the Jev version.

Key observation: the four dimensions are independent of each other—a candidate can perfectly well have Python 3.8 and team leadership 0.5. In a holistic question these two signals dilute each other; split apart, each is crystal clear.

💡 Chinese-language resumes can be scored too, but calibrate first

The official documentation says English is the primary training language with the best accuracy; other languages including Chinese work but with lower accuracy (docs/models.md). Before putting Chinese resumes into production, first run a batch of manually graded resumes and focus on the distribution of confidence across dimensions—wherever a level can't be separated in Chinese, add more situational description to that level.

  • A clear resume gets scores on all four dimensions; swap in a resume with a different emphasis, and each dimension's score changes independently

Step 3: Write the weighted-merge code for Jev composite scoring ​

Why: With atomic scores in hand, the merge rules must live in code, not in the prompt—that's the source of the whole pattern's explainability. How the total score was computed is laid out item by item, fully visible.

The official pattern page's scoring.py is as follows, verbatim:

python
py      = response.answers["python_depth"].score / 4
lead    = response.answers["team_leadership"].score / 4
arch    = response.answers["system_design"].score / 4
general = response.answers["generalist"].score / 4

# Senior IC
ic_score = (0.40 * py) + (0.10 * lead) + (0.40 * arch) + (0.10 * general)

# Engineering Manager
em_score = (0.15 * py) + (0.40 * lead) + (0.20 * arch) + (0.25 * general)

Three ways to read it:

  • / 4 is normalization. Each question has 5 levels, the highest level number is 4, and after dividing everything lands in 0–1. The general form is "divide by the highest level number len(criteria) - 1"—the normalized() in Step 5 of the Score lesson is exactly this general form. The four questions in this lesson share the same scale, so it may look like you can skip the division, but the official version divides anyway—write normalization uniformly, and later if some dimension's scale gets longer or shorter, the merge code won't need to change with it
  • Weights are the product taking a stance. Senior IC: Python depth and system design each get 0.40, team leadership only 0.10; Engineering Manager: team leadership at 0.40 dominates. Both weight sets sum to 1.00, so total scores still fall within 0–1, and the two leaderboards can be compared directly
DimensionSenior ICEngineering Manager
python_depth0.400.15
team_leadership0.100.40
system_design0.400.20
generalist0.100.25
  • Normalize first, then weight—the order cannot be reversed. The meaning of weights is built on the 0–1 scale: 0.40 of Python is exactly twice 0.20 of system design—without normalized scores, that statement does not hold

You should see: ic_score and em_score are each a number between 0–1. For the résumé from step 2, the IC total should be higher than the EM total—that résumé is strong in Python and weak in team leadership, and team leadership alone accounts for 0.40 in the EM weights.

  • My merging code normalizes first (÷ the highest level number) and then multiplies by weights; each of the two weight sets sums to 1.00

Step 4: the same batch of atomic scores, two leaderboards from two weight sets ​

Why: the most beautiful part of this official example is "score once, reuse across roles": the four dimension scores hold for any role; only the weights change. By putting the weights into a dictionary and writing the merge as a function, you have a tool that can rank for any role—while the atomic scores are fetched only once per candidate.

python
WEIGHTS = {
    "senior_ic": {
        "python_depth": 0.40, "team_leadership": 0.10,
        "system_design": 0.40, "generalist": 0.10,
    },
    "eng_manager": {
        "python_depth": 0.15, "team_leadership": 0.40,
        "system_design": 0.20, "generalist": 0.25,
    },
}


def composite(answers, weights: dict) -> float:
    """归一化后按权重合并;算式与官方 scoring.py 一致。"""
    total = 0.0
    for question_id, weight in weights.items():
        top_level = len(RESUME_QUESTIONS[question_id].criteria) - 1
        total += weight * answers[question_id].score / top_level
    return total


def fetch_scores(resumes: dict) -> dict:
    """每个候选人一次请求,拿回四个原子分数。"""
    raw = {}
    with TypeSafeClient() as client:
        for name, resume in resumes.items():
            response = client.system_one(state=resume, questions=RESUME_QUESTIONS)
            raw[name] = response.answers
    return raw


CANDIDATES = {
    "jane": resume,  # 第 2 步那份简历;再放两三份不同侧重的简历
    # "li": ...,
    # "sam": ...,
}

raw = fetch_scores(CANDIDATES)

ic_rank = sorted(raw, key=lambda n: composite(raw[n], WEIGHTS["senior_ic"]), reverse=True)
em_rank = sorted(raw, key=lambda n: composite(raw[n], WEIGHTS["eng_manager"]), reverse=True)

print("Senior IC 榜:", ic_rank)
print("EM 榜:", em_rank)

(The merge formula matches the official scoring.py item by item; the fetch_scores loop and sorting are ordinary Python added by this lesson. One request per candidate, 4 questions in parallel—the same rhythm as the official RAG cookbook's "one request per segment.")

You should see: both leaderboards come from the same batch of atomic scores—fetch_scores ran only once, and the second role, EM, produced no new API calls. If a candidate has deep Python but has never led people, they will appear near the top of the IC leaderboard and near the bottom of the EM one; candidates with solid team leadership experience are the opposite. This is exactly what running two prompts separately can never give you: the two leaderboards are based on the same set of measurements, and the difference comes only from the weights.

  • My second role (EM) did not trigger a second request—the scores come from the same batch of responses

Step 5: when rankings don't match expectations, change only the weights, not the prompt ​

Why: the official summary of this code has two layers: it lets you rank by total score, "but more importantly, it lets you see exactly how the total score was computed"; when the top-ranked candidate doesn't match expectations, "you can adjust the weights to find the right balance." The weights are yours—this exact phrase (The weights are yours) appears once each in the official primitives docs and the Score docs: when the combined result doesn't match your team's standards, change the weights in the code and rerun.

Let's walk through a debugging scenario. The hiring manager looks at the IC leaderboard: "People who have led teams are ranked too low."

python
# 改权重前:python 0.40 / lead 0.10 / arch 0.40 / general 0.10
WEIGHTS["senior_ic"] = {
    "python_depth": 0.35, "team_leadership": 0.20,
    "system_design": 0.35, "generalist": 0.10,
}

# 原子分数已经在 raw 里,直接重算——不用再发任何请求
ic_rank = sorted(raw, key=lambda n: composite(raw[n], WEIGHTS["senior_ic"]), reverse=True)

Three adjustments, to try in order from lowest to highest cost:

AdjustmentCostScope of impact
Change the weight constantsZero API calls (scores are already in hand, recompute locally)Affects only this one leaderboard
Add a dimension (e.g., communication skills)Rerun one request per candidate—but still only one request per candidate, in the official words "The call count stays at one"Every leaderboard using these scores shares the new dimension
Change the scale wording (criteria)Rerun for all candidates; old and new scores are not comparableAll existing scores are invalidated

You should see: after changing the weights, ic_rank immediately recomputes a new leaderboard—not a single number in raw changed, because the questions were not touched at all. This is "change the coefficients, not the prompt": reproducible, auditable, and reversible (change the weights back, and the leaderboard reverts).

  • I treat "changing the weights" as the first lever for debugging rankings, and changing the scale wording as the last

Checkpoint ✅ ​

  • I can state the two steps of Jev composite scoring: one atomic Score per dimension, one parallel request to fetch the scores; then normalize and merge with weights in code
  • I know why we normalize first: different scales have different maximum scores (a three-level scale maxes out at 2, a five-level at 4); only dividing by the highest level number, len(criteria) - 1, puts them on the same scale, so the weights mean what they literally say
  • My weights are code constants summing to 1.00; when rankings don't match expectations, I change the weights first and recompute locally, without sending new requests
  • From the same batch of atomic scores I produced two leaderboards, IC and EM, with zero extra API calls for the second role
  • When sorting I also look at each dimension's confidence: candidates with low confidence get flagged for review rather than ranked rigidly

Pitfall warnings ​

❌ One question asking "is it good overall" ​

The prompt says "Please evaluate this candidate comprehensively and give a score of 1–10"—several judgments crammed into one answer. The official how-to guide lists this as the most important concept in the entire guide:

Broad questions hide several judgments behind a single answer; atomic questions expose those judgments so you can inspect them, tune them, and merge them in code.

With one comprehensive question you can't tell which dimension dragged the score down, and you can't adjust just one dimension. The right approach: one Score per dimension—the four questions in step 1 of this lesson are the paradigm.

❌ Weighting without normalizing first ​

A three-level scale maxes out at 2, a five-level at 4—without normalization, dimensions with more levels naturally get an advantage, and the 0.40 you wrote may actually play a far bigger role than 0.40. The official Score docs specifically stress: divide by the highest level number before merging, "then the weights mean what they say" (Then the weights mean what they say)—0.6 of severity is exactly twice 0.3 of frustration. The four questions in this lesson share the same number of levels, so / 4 looks redundant, yet the official code includes it anyway—precisely to guard against scales growing longer or shorter later.

❌ Changing the scale wording when the ranking is wrong ​

Once the scale changes, the meaning of the scores changes: all candidates' old scores are invalidated, you must rerun everything, and the old and new leaderboards cannot be compared directly. The official action is "change the weights in the code and rerun"—zero cost, immediately verifiable, affecting only one leaderboard (the cost table in step 5). Wording is the last resort: only go back and revise the scale when a dimension's confidence is systematically low (the levels don't separate on your real data), and validate the new scale with known samples following the method in the Score lesson.

❌ Looking only at total scores, ignoring each dimension's confidence ​

The total score compresses four dimensions into one number, and scores from low-confidence dimensions are mixed in invisibly. If a candidate's system_design confidence is only 0.3 (overlapping levels, or insufficient information in the résumé), their total score still computes—but using that total to decide whether they advance to interviews rests on unreliable grounds. The official three-tier usage of confidence applies equally to ranking: high → use directly; medium → flag for review; low → keep that dimension out of the decision and hand off to a human. The full interpretation of the three tiers is in the Confidence lesson.

Advanced techniques (optional) ​

Weighted combining isn't only for Score. The example in section 7 of the official how-to manual uses three Noul probabilities, weighted and combined into a quality score—Noul is already a 0–1 probability, so even normalization is skipped:

python
answers = response.answers

# Combine independent signals into one application-specific score.
quality = (
    0.4 * answers["answers_request"].noul
    + 0.4 * answers["citations_are_supported"].noul
    + 0.2 * (1 - answers["contradicts_context"].noul)
)

(Official code as-is, docs/concepts/how-to-build-with-system-one.md. Note the third signal takes 1 - noul: the lower the probability of contradicting the context, the higher the quality score.)

Let the machine learn the weights. Weights don't have to be hand-tuned forever. The same section of the official docs gives an advanced path: treat the probabilities of each question as features and feed them to a downstream classical machine learning model to learn the combination; when there are no labels, you can use a set of expensive inference models as an ensemble to generate labels. The official AutoResearch cookbook (autoresearch_feature_discovery, not yet a standalone page) demonstrates the full approach: the autoresearch loop proposes TypeSafe questions, converts free text into numeric features, trains a CatBoost regressor, and then uses the model's errors to improve the questions in turn.

Signal combination in real scenarios. The idea of "multiple signals, combined in code" shows up everywhere in the hands-on lessons:

  • RAG passage gating: ask 4 Noul questions for each retrieved passage (is it relevant, does it contain evidence, does it contradict the premise, does it contain an injection), and the code decides which ones go into the answering model's context. The officials specifically point out: none of the four questions asks "should this passage be included"—that decision lives in the code; changing the standard means changing a number, no rewriting of questions needed
  • Search and matching: reranking is a pure ranking form—one Noul per query-candidate pair, sorted by probability; official tests show top-1 hit rate of 5%→18%; entity alignment is a combined judgment of 1 Score plus 3 Noul

Lesson summary ​

✅ Jev composite scoring = the official Composite scoring pattern: break a complex judgment into one atomic Score per dimension, fetch them all in parallel in a single request, then normalize and weighted-combine in code—officially labeled with the benefits Cost, Reliability, Speed, the only one of the four patterns to hit all three.

✅ Weights are product decisions: Senior IC 0.40/0.10/0.40/0.10, Engineering Manager 0.15/0.40/0.20/0.25—the same set of atomic scores, two sets of weights, two leaderboards, and the second role costs zero extra requests.

✅ Explainability is the biggest benefit: how the total score is computed, every dimension's score and weight are all visible in code; when a ranking looks wrong, adjust the weights and recompute locally—reproducible and reversible.

✅ Adding dimensions doesn't add requests: add one question to the question dictionary, and the call count per candidate stays 1—officially stated as "The call count stays at one".

Key facts at a glance:

ItemValueSource
Pattern in one sentenceCombine several dimensions of analysis into a single scoredocs/patterns.md
Pattern definitionBreak a complex judgment into atomic scores, combine with weights you control in codedocs/patterns/composite-scoring.md
Four questionspython_depth / team_leadership / system_design / generalist, each a 5-level scaleOfficial Playground (patterns/composite-scoring, extracted from the rendered page)
Normalizationscore ÷ (len(criteria) − 1), in this example ÷ 4 per questiondocs/primitives/score.md
IC weightsPython 0.40 / team leadership 0.10 / design 0.40 / generalist 0.10docs/patterns/composite-scoring.md (scoring.py)
EM weightsPython 0.15 / team leadership 0.40 / design 0.20 / generalist 0.25same as above
BenefitsCost, Reliability, Speeddocs/patterns.md

Composite scoring is a pattern at the "how the answers are used" layer; before going live, it still needs to go through the nine failure modes in the Jev 1.13 pitfall handbook—especially the "literal interpretation" one: write precise conditions in scale descriptions, not degree words like "has fairly good architecture skills".

Next lesson preview ​

With this lesson, we have covered all four official patterns (fan-out, intent routing, confidence gating, and combined scoring). One last question remains: who writes the code that calls Jev. In the next lesson developing in combination with Claude Code: TypeSafe Agent Skill.

You will learn:

  • Jev is not a coding agent's LLM: it cannot replace the model behind Claude Code / Cursor; the right approach is to have the agent write "the code that calls Jev"
  • Two commands to install the official Agent Skill: claude plugin marketplace add typesafe-ai/skills, then claude plugin install typesafe@typesafe-ai
  • 3 official example prompts: brainstorming, running cheap experiments, finding similar cookbooks
  • 5 troubleshooting methods for common problems: the agent doesn't use the skill, routing doesn't match expectations, confidence thresholds set everywhere, code is hard to review, the agent fabricates fields
gaodong.aiAboutPrivacyContact

Independent tutorials, not affiliated with any product mentioned. Product names and trademarks belong to their owners. Check official pages for prices and policies.