Skip to content
One real scan, start to finish

What Concept Scanner gives you, shown on a real scan.

We ran the current release on groupcache, a public Go caching library, on one computer with the default local model. Here is what came back, how to check it, the decisions you make, and what you leave with.

Free for Mac and Windows. Runs on your own computer by default.

What you get

The engineering decisions in a project, each written up in plain language: what it does, the problem it solves, how, and its parts.

How you check it

Every concept names its file and lines, quotes the line its reasoning rests on, and lists the tests that exercise it.

What you decide

You approve, reject with a reason, or skip each finding, and correct the figure. What you share is the record you corrected.

What it leaves to people

Whether anything is new, inventive, eligible for a patent, or whose it is. Those are questions for you and a practitioner.

1

The scan

We pointed the app at a copy of groupcache: twelve Go files of caching code, with its tests and its full git history. It ran unattended with the Balanced model profile, on an Apple M4 Max with 128 GB of memory, and everything stayed on that computer.

12 of 12source files read
22candidate mechanisms found
12 + 10shipped for review, and held back with a reason
26m 30sunattended, with nothing billed per token
The Concept Scanner window opening the review of the groupcache scan: counts to review and held back, a note on what the list order is worth, and filters for pending, exported, rejected, all and held back.
The review opens by saying what the list order is worth: a starting point, not a ranking. Read the whole list. Every screenshot on this page is from the released app; tap or click one to open it full size.
2

One mechanism, written up

The concept we follow is the one the scan listed first. groupcache keeps two caches: one for the keys a server owns, and a smaller “hot” cache of popular keys copied from other servers. When memory runs out, something has to decide which cache gives up an entry. The scan found that decision and wrote it up.

A concept card in the Concept Scanner window: Dual-cache with eviction prioritization, marked exported, with its technical field and summary.
The concept as the window shows it, marked exported after the review in step 7.
For the engineer

This is a decision someone made once and never wrote down. Seeing it named is the first step to deciding whether it matters.

For the practitioner

A technical field, a summary, the approach, the components and how they interact: the material an intake starts from, before anyone has been interviewed.

3

The code behind it

Every concept names its file and lines, worked out by the program from the declarations the concept names rather than guessed by the model, and links to them on GitHub at the exact commit scanned. Here is the heart of it, with the line its distinctiveness reasoning rests on highlighted:

groupcache.go, lines 352 to 368, at commit 2c02b82

	// Evict items from cache(s) if necessary.
	for {
		mainBytes := g.mainCache.bytes()
		hotBytes := g.hotCache.bytes()
		if mainBytes+hotBytes <= g.cacheBytes {
			return
		}

		// TODO(bradfitz): this is good-enough-for-now logic.
		// It should be something based on measurements and/or
		// respecting the costs of different resources.
		victim := &g.mainCache
		if hotBytes > mainBytes/8 {
			victim = &g.hotCache
		}
		victim.removeOldest()
	}

What to notice

The rule

The hot cache gives up an entry once it holds more than an eighth as much as the main cache; otherwise the main cache does. The scan cited this line, and the program checked that the line it cited is there.

What the author said

The comment above it calls this “good-enough-for-now logic”. The scan rated the mechanism distinctive; the person who wrote it thought of it as a placeholder. Only a person can weigh that.

Where the write-up slips

One of the scan's notes says it “evicts from the larger one”. The code evicts from the hot cache once it passes an eighth of the main cache, which is not the same thing. Your review is where that gets caught.

The concept's location in the window: groupcache.go lines 346 to 469, the declarations the lines came from, the commit, a link to the lines on GitHub, and its engineering signals, each with the named level it stands for, above Approve, Reject and Skip buttons.
Where it lives, and the scores. Each score is one of four named levels, shown with its name, such as “unusual on the scale”.

Across this scan the program checked 17 quotes behind distinctiveness claims: 14 were found in the cited file, 2 were not, and 1 was too short to check. It reports the misses rather than hiding them.

4

The tests that exercise it

Each shipped concept is paired with the tests that use the code it cites. For this one the scan named eight, among them TestCacheEviction at line 189 of groupcache_test.go. All twelve concepts in this scan were paired with tests.

The model can also be asked what those tests assert, and a statement is kept only if it quotes the test. Here the program rejected the model's claim that the eviction test checks eviction from “the larger cache”, because that wording is not in the test. The tests are read, not run: whether they pass is a question for the people who own the code.

For the engineer

A ready list of the tests to point to when someone asks how you know it works.

For the practitioner

Where to look for evidence that the mechanism operates as described, and a prompt to ask whether those tests have been run.

5

Who wrote it

The scan runs git blame over the cited lines. For this concept: 41 lines by Brad Fitzpatrick, all from groupcache's first commit on 23 July 2013. The record carries its own caveat beside that list: “Code authors are not necessarily legal inventors; inventorship requires human determination.”

For the engineer

A dated trail of who wrote what, which helps when you reconstruct how an idea came about.

For the practitioner

A starting point for the inventorship conversation, not its answer. With AI-written code, who typed and who conceived are often different people.

6

A figure, corrected by a person

The scan can draw how a concept's components connect, one model call per figure. Every box cites one of the concept's own components; a box the model added on its own would be drawn dashed. The first drawing missed the rule itself, so we added two arrows: the hot cache is chosen once it exceeds an eighth of the main cache, and the main cache otherwise. Arrows a person draws are exported with the concept; the model's own are not.

A diagram of five components: main cache, hot cache, cache bytes limit, populate cache and victim cache pointer, with arrows for adding items, checking the limit, comparing sizes and removing the oldest entry, and two added arrows: chosen when hot bytes exceed one eighth of main, and chosen otherwise.
The figure as saved from the window, with the two arrows we added: “chosen when hot bytes exceed 1/8 of main” and “chosen otherwise”.
7

Your review

Nothing is exported until you decide. For each finding you approve, reject with a reason, or skip. In this scan we approved the eviction concept, rejected a second concept that described the same eviction rule again as a duplicate, and rejected a concept about choosing an HTTP transport per request as routine, a common Go pattern.

The bottom of a concept card with its engineering signals, the Approve, Reject and Skip buttons, and a reason chooser set to routine beside Reject it and Cancel.
Rejecting asks for a reason: duplicate, routine, wrong location, inaccurate, or other. A rejected concept cannot be exported, and the reasons stay on your computer.

Reviewing your own scan? How to check a concept against its code and correct it, worked on this same concept.

8

What you take away

Every scan writes a summary file that lays each concept out under the headings a reader expects: technical field, summary, figure, detailed description, what is unusual, comparable techniques, where it lives in the code, and its signals, with your decisions marked. It is rewritten as you review. Export then writes each concept you approved as its own file, recording the repository, the exact commit it describes, your arrows and the authorship caveat.

From the exported concept (abridged)

"review_status": "approved",
"location": { "file": "groupcache.go", "start_line": 346, "end_line": 469 },
"component_edges": [
  { "from": "c2", "to": "c5", "label": "chosen when hot bytes exceed 1/8 of main" },
  { "from": "c1", "to": "c5", "label": "chosen otherwise" }
],
"source_audit": {
  "repository": "https://github.com/golang/groupcache",
  "commit_hash": "2c02b8208cf8c02a3e358cb1d9b60950647543fc"
}

A concept record is engineering documentation. It is not an invention disclosure and not a patent application, though it is a far better starting point for either than a blank form.

9

The questions it leaves

A good record ends in better questions. From this one concept:

For the engineer

Was the one-eighth rule a considered choice or, as the comment says, good enough for now? What else was tried? Did anyone measure it?

For the practitioner

Who conceived the rule, and when? This code has been in a public repository since 2013, so what does that mean for anything built on it? What do the tests show, and do they pass?

What left the computer during this scan.

Nothing. The scan above ran against a local model through Ollama, so the code, the model's answers and the results stayed on the computer. That is the default. Here is how it changes with the setup you choose.

Where your code goes, by how Concept Scanner is set up.
SetupWhere your code goes
Default: Ollama on your computerNowhere. The scan's own summary records where its code went, so you can check.
A cloud provider you choose, on your own keyTo that provider, under its terms.
The GitHub ActionTo the provider named in your workflow file, or nowhere beyond your runner if it runs Ollama itself.
Checking for updatesOnly if you say yes: it asks GitHub whether a newer release exists. No code is sent.

Scanning confidential code? --local-only makes local a hard rule, and every other connection is listed there.

What a scan does not tell you.

These are the questions a scan helps you ask. Answering them is work for people.

Whether it is new

The scanner reads one codebase. It does not search patents or publications, so it cannot say whether anyone has done the same thing.

Whether it could be patented

Eligibility, novelty and non-obviousness are legal questions about claims, decided by a practitioner and the patent office.

Who invented it, or who owns it

Git history shows who wrote the lines. Who conceived the idea, and who holds the rights, are separate questions. Why that matters when AI wrote the code.

Whether the description is right

The program checks that a cited line exists and that a quote matches it. Whether the explanation is accurate is what your review is for.

Questions people ask.

How long does a scan take?

It runs unattended, so you can get on with your work. Time grows with the size of the project and depends on the model and the computer. The twelve-file scan above took 26 minutes 30 seconds on an Apple M4 Max, and an earlier release took about 39 minutes over the much larger PX4 flight stack. A larger model profile surfaces more and takes longer.

Can it read documents as well as code?

Yes. Point it at a folder of Markdown, text, PDF or Word documents and it reads them the same way, which suits design documents and proposals written before the code. PDFs need a text layer; a scanned page is an image and is not read. Repository scans are the path we have measured most; tell us how documents work for you.

Which languages does it read?

It reads most common languages, among them Go, Python, TypeScript, JavaScript, Rust, C and C++, Java, Kotlin, C#, Ruby and Swift. Line numbers are found for Go, TypeScript, JavaScript and Python, from the declarations a concept names; in other languages a concept points to its file. Associated tests are paired for Go and Python.

Should I trust the scores?

Treat them as a structured reading of each mechanism, on four named levels, that you can compare and argue with. They are not a ranking of value: in a labelled test the default order separated worth-reading mechanisms from routine ones at 0.54, where 0.50 is chance. Read the whole list.

What do I give a patent practitioner?

The scan's summary file, with your decisions in it, and the concepts you exported. Our page for practitioners shows what they will look for in it.

See what your own code contains.

Linux, the terminal and what your computer needs: the download page.
A larger example: 27 concepts from the PX4 flight-control codebase.