---
title: "Consult guide: could Jev help this project?"
type: guide
source_tier: mixed
tags: [consult, project-assessment, ideas, decision-mapping, token-budget]
created: 2026-09-20
updated: 2026-09-21
confidence: medium
sources:
  - raw/x-repos/ryana__jevify.md
  - raw/nate/jev-shaped-problems.md
  - wiki/guides/agent-integration-playbook.md
  - wiki/concepts/jaggedness-jev-1-13.md
  - wiki/concepts/system-one.md
  - wiki/reference/models-and-pricing.md
  - wiki/guides/choosing-a-primitive.md
  - raw/x/INDEX.json
jev_version: "jev-1.13.0"
summary: "Procedure for an agent asked 'here is my project, could Jev help?': what to read (10-15k tokens), how to find and filter decisions, and the shortlist format to return."
---

# Consult guide: could Jev help this project?

> **TL;DR** Someone shows you a project and asks whether Jev fits. List the project's *decisions*, keep the ones that are narrow, semantic and frequent, match each to a pattern via the [[ideas/patterns]] index and one domain page, and return a ranked shortlist with cost, fit and caveats. Read about 10-15k tokens of this wiki, not the whole corpus. "Jev does not help here" is a valid answer.

## Reading budget

`[[dir/slug]]` resolves to `https://jevwiki.ai/raw/wiki/dir/slug.md`. Skip `llms.txt` (~7k tokens) unless you need a page not linked here.

| Step | Page | ~Tokens | When |
|---|---|---|---|
| 1 | this page | 2k | always |
| 2 | [[ideas/patterns]] (index of every pattern) | 2k | always |
| 2b | ONE domain page the index points to ([[ideas/patterns-agents]], [[ideas/patterns-interface]], [[ideas/patterns-data]], [[ideas/patterns-business]]) | 1.5-4.5k | always; a second one only if the project clearly spans two domains |
| 3 | [[concepts/jaggedness-jev-1-13]] | 3k | if any candidate touches numbers, dates, long state, or adversarial input |
| 4 | [[ideas/field-reports]] (verdicts), [[ideas/measurements]] (numbers), or the [[ideas/community-repos]] index then one repo page | 3-4k | only when a pattern's "Seen in" points there, or the user asks "does this really work?" |
| 5 | one official pattern or cookbook page named in the pattern's **Map** line | 2-5k | only for the top 1-2 candidates, to sketch the design |
| alt | [[guides/choosing-a-primitive]] | 3.4k | only when a surviving decision matches no pattern; it replaces step 5, not adds to it |

Skip `llms-full.txt`, the SDK and the HTTP reference until the user decides to build; then use [[guides/agent-integration-playbook]].

## Procedure

1. **Get the project in front of you.** Read the repo, spec or description. You need: inputs, outputs, where an LLM or a pile of `if`s makes a judgment today, daily volume, latency needs.
2. **List the decisions, not the features.** One line per judgment: "is this ticket urgent", "which of 40 tools applies", "does this diff need a human". Include decisions made today by LLM calls, regexes, keyword lists, heuristics or a human queue, AND judgments the project skips because they seemed too expensive: sampling instead of checking every item, coarse categories, delayed batches (idea from the [jevify prompt](https://github.com/ryana/jevify)).
3. **Filter each decision with the fit test below.** Drop the ones that fail. Be strict; most value is in 2-5 decisions.
4. **Match survivors to patterns.** Find the closest `Pxx` in the [[ideas/patterns]] index, open the domain page that holds it, and take its primitive, its fit verdict and its **Map** links. No match is fine: design it from [[guides/choosing-a-primitive]].
5. **Group, then estimate cost and latency.** First group surviving decisions by shared state: every question about the same email, ticket or page goes in ONE call ([[patterns/fan-out]]); cost the call, not each decision. Input tokens per call = state + all questions. Cost = tokens x $0.042 per million for `jev-1.13.0` / `jev-latest`; output is free. Worked example: 350-token email + 10 questions (~400 tokens) = ~750 tokens/call; x 40,000 calls/day = 30M tokens/day = $1.26/day, about $38/month. Limits: 64k tokens per request, 32k for state plus the longest question, 1,200 requests/min, 250k tokens/s ([[reference/models-and-pricing]]). TypeSafe states 70-500 ms per call; community reports vary ([[ideas/field-reports]]).
6. **Return the shortlist** in the format below, best first, and say what you would *not* use Jev for.

## Fit test

| Signal | Verdict |
|---|---|
| Output is one of a known set, a yes/no, or a rating on a rubric | required; otherwise stop |
| Needs semantic understanding that rules or regex handle badly | strong |
| Happens often (per message, per step, per row) or sits on a latency-critical path | strong |
| You can act differently on low confidence (escalate, ask, skip) | strong; see [[patterns/confidence-routing]] |
| Replaces an LLM call whose answer is parsed into a branch | strong |
| Needs arithmetic, counting, date/time comparison, exact thresholds on numbers | poor; compute in code, ask Jev only the semantic part |
| Needs several hops of inference or implicit intent | workable only if split into literal questions |
| State is large and mostly irrelevant | workable only after filtering state |
| Needs generated text, explanations, code, summaries | not Jev; use an LLM, optionally with Jev as router/judge around it ([[syntheses/jev-vs-llm-structured-outputs]]) |
| A simpler tool already works: a rule, a cache, embeddings, a classifier they own | keep it |
| It is one question, asked once | skip; setup is only repaid by repetition |
| Wrong answers are costly and there is no review path | workable only with confidence gating and an eval set ([[guides/testing-and-evaluation]]) |

## Shortlist format

Return a table, then two short paragraphs. Tag each row `saving`, `better outcome` or `new capability`. **Fit** is `strong` (do it), `workable` (only with the stated mitigation) or `poor` (do not; say what to use instead). When several rows share one call, put the cost on one "shared call" row and write "shared" in the others.

| # | Decision in this project | Pattern | Ask (primitive + criteria sketch) | Code does | Fit | Est. cost / volume | Caveat |
|---|---|---|---|---|---|---|---|

- **Recommended first step:** the single cheapest experiment: one decision, ~50 past cases with known answers, note the confidence of every miss, then shadow mode ([[guides/testing-and-evaluation]]).
- **Not recommended:** the parts of the project where Jev is the wrong tool, and why.

## Rules for the advisor

- Official pages win. `ideas/` is community-sourced; when a post disagrees with `reference/` or `concepts/`, follow the official page and say so. Keep vendor claims, measured results and your own hypotheses apart.
- Attribute performance numbers ("@handle reports ..."); do not promise the launch multipliers.
- Keep the user's project details in your own session.
- Trading, betting and other money-moving ideas: describe the engineering only, flag the numeric and time-series weakness, give no financial advice.
- Access is gated (early access); check [[entities/typesafe-console]] before promising availability.

## More precedents

A larger unaffiliated demo list: https://jevdemos.netlify.app (curated by @thisiskp_). Titles, one-liners and videos; browse it once a pattern here has matched. Not mirrored here.

## Related

- [[ideas/overview]] — what the ideas section contains
- [[ideas/patterns]] — the pattern bank this procedure matches against
- [[ideas/field-reports]] — independent results and critiques
- [[ideas/community-repos]] — working code to borrow from
- [[guides/agent-integration-playbook]] — switch to this once the user decides to build
- [[concepts/use-case-map]] — TypeSafe's own industry map

## Sources

- wiki/guides/agent-integration-playbook.md, wiki/concepts/jaggedness-jev-1-13.md, wiki/concepts/system-one.md, wiki/reference/models-and-pricing.md, wiki/guides/choosing-a-primitive.md
- raw/x/INDEX.json (61 curated community posts, captured 2026-09-20)