# Show HN: Decide – decision model CLI for analyzing large codebases with Jev

> Source: <https://decide.deepnoodle.ai/>
> Published: 2026-11-13 15:32:03+00:00

**v0.5.0** OpenAI's Decisions API and Go templates →
# Judgment calls, at scale.

Find the vulnerable function in a codebase, the urgent ticket in a queue, the risky change in a pull request. decide asks a decision model about every one, from your shell, CI, Go code or Claude Code.

``` bash
$ brew install deepnoodle-ai/tap/decide
bash
$ go install github.com/deepnoodle-ai/decide/cmd/decide@latest
bash
$ go get github.com/deepnoodle-ai/decide
> /plugin marketplace add deepnoodle-ai/decide> /plugin install decide@decide
```

## The small calls inside your automations.

Every pipeline has judgment calls that are too many for a person and too fuzzy for a rule. Here are a few that decide makes out of the box.

## What you’d otherwise build yourself.

A decision model’s API takes one text and one question. decide brings the questions, splits your data into items, and gives your script something to act on.

### Questions, already written

Twelve built-in templates, each a set of questions with tuned wording and flag thresholds. Write your own in a few lines of JSON.

`$ decide templates`

### Code, function by function

decide splits Go, Python, JavaScript, TypeScript and Java into functions and sends each with its imports. On a diff, it asks only about the functions that changed.

`$ decide run code-risk src --each function`

### Any data, item by item

Point it at JSONL, CSV, Markdown, a diff, or a folder of images or PDFs. Each record, section, hunk or file gets its own answer, and long ones are judged in parts.

`$ decide run relevance docs --each section`

### No question asked twice

Every answer is kept. Run again and decide asks only about what changed, so a second pass over a codebase costs almost nothing.

`81974 answers from cache · 450 asked`

### Output a script can act on

A flagged answer can exit 2. Results print as JSON, CSV, a Markdown report or GitHub annotations, and a stopped run resumes where it left off.

`--fail-on flagged --format github`

### The same from Go

Typed questions from your own program, with validated answers, retries, a fake server for tests, and patterns such as gate, rank and funnel.

`$ go get github.com/deepnoodle-ai/decide`
## Audit a whole codebase from Claude Code.

Two skills in the decide plugin. decide scores every function, and Claude reads only the few that score highest.

- /decide:audit ### Audits a repository for security bugsdecide scores every function with the security template. Claude reads up to 15 of the highest with their callers, and reports which are real.
- /decide:hunt ### Finds where a fixed bug was repeatedGive it a fix commit or pull request. Claude writes one question about the mistake, decide asks it of every function, and Claude reads the top matches.

In Claude Code

```
> /plugin marketplace add deepnoodle-ai/decide> /plugin install decide@decide
```

Needs the decide CLI and a key for a decision model. Once installed, the plugin also checks what Claude reads and runs.

[Claude Code guide →](https://decide.deepnoodle.ai/reference/claude-code/)

## Why not just call an LLM?

You can, and for writing or reasoning you should. For a yes or a no on every item, a decision model is the better tool.

### Faster

An LLM writes its reply a token at a time, and you wait for all of it. A decision model writes nothing. It returns one answer.

### Cheaper

With an LLM you pay for your prompt and for every token it writes back. Here you pay for the prompt.

**$0.042** per million input tokens on Jev[1](#price-note)

### Calibrated

Ask an LLM how sure it is and it types a number, usually a confident one. A decision model is trained so its probability matches how often it is right.

**90%** means right about nine times in ten

<sup>1</sup> Jev bills input only ([TypeSafe](https://docs.typesafe.ai/models)). gemini-decision-1 bills $0.10 per million input tokens and writes no output tokens ([Google](https://aistudio.google.com/docs/pricing)). OpenAI's Decisions API and Cloudflare bill on their own terms. For scale, the lowest standard price OpenAI lists for a chat model's output is $0.40 per million tokens, for gpt-5-nano ([OpenAI](https://developers.openai.com/api/docs/pricing)).

## Close calls go to a person.

Every answer comes with a probability. Act on the ones the model is sure of, and send the rest to a person.

### Before you switch, test it on your own items.

Run it on items you've already labeled and compare. The probability is the model's judgment, not proof, so set your thresholds there too.

[See examples/calibrate →](https://github.com/deepnoodle-ai/decide/tree/main/examples/calibrate)

## Four decision models, one set of commands.

All four read text and code. Three read images, and Gemini reads audio, video and PDFs too. Jev is the default; switch with one flag.

### TypeSafeJev · default

`jev-latest`
- text

### CloudflareClef · Workers AI

`clef`` clef-flash`
- text
- images

### OpenAILuna

`gpt-6-luna`
- text
- images

### GoogleGemini

`gemini-decision-1`
- text
- images
- audio
- video

Bring your own key. decide sends what you ask about to that provider and nowhere else. Keys and switching are in [Providers](https://decide.deepnoodle.ai/reference/providers/).

## Your turn. Ask it something.

Install it, set a key, and put it where your script makes a call.

``` bash
$ brew install deepnoodle-ai/tap/decide
```

Open source under Apache 2.0. [LICENSE](https://github.com/deepnoodle-ai/decide/blob/main/LICENSE) · [CONTRIBUTING.md](https://github.com/deepnoodle-ai/decide/blob/main/CONTRIBUTING.md)

decide is Apache 2.0. Made by Deep Noodle, after some very hard thinking.