Applied AI-Powered Bioinformatics Tools

CRISPR Candidate Record Checker

Last reviewed

Intermediate

What you'll learn

~50 min
  • Ask an AI tool, in plan mode, for a program that reads a core's exported candidate records and the order they were made for, and compares them under the core's numbered record-checking rules
  • Point it at the core's rules file, and read its plan for what matters: every rule by number, every source row kept, repeated IDs marked on every row, exact comparisons, whole recorded spans, unknown history kept apart from a recorded none, and every check not made shown
  • Check its list, and its lists for incomplete and conflicting records, against findings worked out for the practice files
  • Say what a mark, and nothing flagged, can and cannot tell you, and who reviews the evidence and authorizes a proposal

The story, and what you will end up with

This lesson is about checking candidate records against an order. The program you build reads a table that the core’s design software has already exported, compares it with the order under the core’s written rules, and lists what needs a look. It designs, scores, ranks and chooses nothing, and sends nothing anywhere. It is Thursday 12 November 2026 at a made-up genome-editing core. You are the staff scientist preparing a records review for order ORD-2, revision R2. The design work has already happened; you have a reduced table of its recorded details to compare with the order.

At this made-up core, you reconciled the requesting lab’s research objective and model context with the core’s interpretation, checked the reference record and its version, the coordinate convention (how positions are numbered) and requested interval, and looked at the design run’s provenance (the record of which run, program version and settings produced the table) and its settings record. You located previous work, including older candidate identifiers, and recorded the unresolved questions and who is to answer each. The practice files contain only labels for that work. Two matching reference labels could both have been copied from the same mistaken record; agreement between them cannot establish which reference was used.

Now you want the exported records checked without losing repeated rows or overlooking a blank. By the end of this lesson you will have a small program on your own computer that lists every row, the recorded differences that need a look, and the checks it could not make, on screen and in a file your spreadsheet opens. You build it by asking your AI tool in plain English, and you check it against findings this lesson gives you.

🔍Words used in this lessonclick to expand
  • Order: here, a recorded request and its revision, not permission to select or order anything.
  • Candidate ID: a label in these records. Counting distinct labels does not establish distinct biological identities.
  • Reference ID: here, REF-2 names one particular invented reference version.
  • Recorded span: the lower and upper numbered positions in the candidate row. This practice core counts from one and includes both ends; the positions are not a cut location.
  • Provenance: the record of where the table came from, including which run, program version and settings it says were used.
  • Already tried: an ID linked to earlier work in this order’s history. It says nothing about the outcome.
  • Checks not made: required comparisons the available records do not allow. They are shown separately from findings.
  • Checksum: a code worked out from a file’s contents, used here to distinguish input versions.

Before you start

First, if your AI tool is still open, leave it: type /exit and press Enter (if you use Antigravity, press Ctrl+D with nothing typed instead), and wait until you see the $ or % prompt. The next line goes there, in the terminal, not in the AI tool. It makes a folder for this lesson beside your practice folder and goes into it:

Terminal window
mkdir -p ~/bio-workbench/02-candidate-check && cd ~/bio-workbench/02-candidate-check

Start your AI tool with the start line you kept from the setup lesson, the one with approval prompts off. Then ask it to set the folder up:

Set this folder up so we can undo any change you make, download https://learn.intellimetrics.net/starters/biotech/02/candidate-records.zip and unpack it into a data folder, and save a checkpoint.

Look for it saying three things: the folder is set up with Git (the program that saves snapshots, from setup), the practice files are in the data folder (candidates.csv, order.csv, candidate-rules.txt and the check-cases folder), and a first snapshot, your checkpoint, is saved. Later you can ask whether the files have changed since then. If it does not mention one of them, ask: “Did you save a checkpoint with the files in it?” It may also keep the zip file in the data folder, which is fine; if it says it kept one somewhere outside this folder, ask it to delete that copy. If the download does not work, download candidate-records.zip in your browser, check where it went (the browser’s list of downloads shows the folder), and tell your AI tool, for example: “candidate-records.zip is in my Downloads folder. Unpack that one file into a data folder here, and save a checkpoint.” In Windows PowerShell or a desktop app, “my Downloads folder” works as is; only say “my Windows Downloads folder” if you use Ubuntu (WSL) on Windows, which keeps its own Downloads folder apart from Windows.

The box below says what is in the practice files; later steps refer to them.

ℹWhat is in candidate-records.zipclick to expand

Two main files, each of which opens in a spreadsheet program, a rules file that opens in any text editor, and nine pairs of extra records in check-cases:

  • order.csv: one row, ORD-2 revision R2, requested 9 November 2026 by LAB-31, run RUN-2, target TGT-7, reference REF-2, requested interval 200 to 500 including both ends, convention one-based-inclusive, program DESIGN-X version 4.2, settings CFG-A, Already_Tried G-06.
  • candidates.csv: nine rows exported 10 November 2026. Each carries the order, revision, run, target, reference, coordinate convention, recorded span, program, version and settings. Source row numbers count from 1 after the heading.
  • candidate-rules.txt: this practice core’s six numbered record-checking rules, version CR-1, marked PRACTICE MATERIAL. They cover incomplete input, repeated IDs, exact comparisons, whole spans, previous-work history and what a list may say.
  • check-cases: nine folders, each with its own order.csv and candidates.csv, for the incomplete and conflicting records in the check list below. Each pair is checked separately under the same rules.

Every row is marked PRACTICE MATERIAL. The main candidate rows all record ORD-2, R2, RUN-2, TGT-7, one-based-inclusive and DESIGN-X. Their other values are:

Data rowCandidate_IDReference_IDGuide_StartGuide_EndProgram_VersionSettings_ID
1G-01REF-22002194.2CFG-A
2G-02blank2602794.2CFG-A
3G-03REF-23203394.2CFG-A
4G-03REF-23203394.2CFG-A
5G-04REF-24905094.2CFG-A
6G-05REF-23503694.1CFG-B
7G-06REF-24004194.2CFG-A
8G-07REF-24815004.2CFG-A
9G-08REF-22202394.2CFG-A

Here blank means an empty cell. In Already_Tried, the exact word none records a known empty history; an empty cell means unknown. A list of IDs uses semicolons. These IDs are stable within this invented order only.

This is a reduced records exercise, not a complete design export. It holds no sequences or scores, and the equal span lengths carry no rule. Everything in these files is made up for this course: every identifier, position, date, software label and rule. No real design program produced them; no real gene, organism, strain, investigator or institution is represented. Each lesson in this track has its own practice files, with their own people and dates.

Switch to plan mode

Your AI tool is already open. Switch to plan mode now: Shift+Tab until it says plan, or /plan (the keys for each tool). In plan mode it usually reads your files, asks its questions and shows you a plan before it builds anything; the order can vary.

The conversation

Each message below is an example. Say it your own way.

Say what you want

Say what you do, which files to use, and what you want from them:

I check candidate records at our genome-editing core. Build a reusable program that checks the candidate table against the order sheet in data and lists what needs a look, with reasons. Ask me what you need first.

Your AI tool usually reads the files and comes back with questions, starting with your rules. It may already point out some of what it sees in the files. Leave its questions for now: send the two messages below first, then answer them. Your AI tool may wait for your answers or go straight on to propose a plan; either way, do not approve a plan until the two messages are sent.

Point it at your rules

These are this practice core’s own rules, in its rules file. Your core’s are in its own written procedures; later in this lesson you write them into a file of your own. Even if your AI tool has already read the rules file, tell it these are the rules to follow:

Our core's record-checking rules are in candidate-rules.txt in data. Follow all six, and name the rule beside each finding and each check not made.

Wait for its reply, then say what the list must identify and what you need to see before using it:

Identify the files, their checksums, order revision and rule version on every list. Show every source row and reason. Before I use it, demonstrate every check-case folder. Leave inputs unchanged and never overwrite earlier lists.

The requested interval and coordinate convention are this practice core’s own, recorded for this made-up order; no scientific threshold is applied. The program compares recorded values; it does not establish that the recorded settings or reference were used.

Answer its questions

Answer each in a sentence. These are questions the tools often ask, with one way to answer each. Yours may ask them in a different order or show a list of choices:

If it asksYou might say
What should it be written in, or how will you run it?Use whatever needs the least installed and works with no internet.
Where should the list appear, or in what form?On screen, and a file my spreadsheet program opens, each with the header.
Should the rules file be followed exactly?Yes, follow CR-1 exactly.
Do the results it expects match yours? (Compare them with the checks under Look at what it built.)Yes, those match the expected findings.
Its defaults for points the rules do not settle?List each one. Compare exactly as written and add no rule CR-1 does not state.

If it asks several questions at once, answer the ones about your rules and how records are counted from your core’s own procedures, a sentence each, and accept its suggestions only about how the list looks. If you cannot tell which kind a question is, treat it as a rule. If it asks something not listed here, answer it the same way, in a sentence.

Read the plan

Next it usually shows you a plan: what it will build and how it will check it. Read it for six things:

  1. Every rule in the rules file is in the plan, by its number: 1 incomplete input, 2 repeated IDs, 3 exact comparisons, 4 whole spans, 5 previous-work history, 6 what the list may say. Missing fields, unreadable or reversed positions, missing columns, an empty export and an ambiguous order are visible; checks not made are never shown as completed.
  2. Every source row is retained, with original values beside requirements and all reasons. Every occurrence of a repeated ID is marked, including conflicting occurrences. Row counts and distinct nonblank ID counts are separate.
  3. Order, revision, run, target, reference, coordinate convention, program, version and settings are compared exactly. A blank is a missing value, not an extra mismatch, and independent checks still run.
  4. The whole recorded span is compared only when its target, reference and coordinate convention match and both intervals can be read. Both endpoints are included; no length rule or coordinate conversion is added.
  5. Unknown history stays distinct from a recorded none. The list uses “needs a look”, “nothing flagged” and “checks not made” as rule 6 defines them, with no selection or recommendation.
  6. It is a program you can run again, with input checksums, order revision and rule version on every list. Inputs stay unchanged, earlier lists stay in place, and every check-case pair is demonstrated before use.

A first plan often leaves one of these out, even when you have asked for it. Say so in a sentence, in your own words, for example:

Keep both copies of a repeated ID, mark each, and count rows separately from IDs. Don't choose which to keep.

When the plan has all six, approve it: if your AI tool offers a choice to go ahead, pick it; otherwise say “Yes, go ahead and build it.” In Codex, press Shift+Tab first to leave plan mode. In Copilot, saying it brings up a choice to go ahead; pick that. Let it build. It may run what it built and tell you how to run it yourself; either way, the next step asks it to. When it has finished, ask it: “Did you install anything, and where?” Nothing, or something inside this lesson’s folder, is fine for these lessons. If it names anywhere else on your computer, such as the zip file it downloaded, ask it what that is for, and to remove it if you do not want it there.

Look at what it built

Ask it to run what it built:

Run it on the files in data and show me the list.

Your list will be worded and laid out in its own way. Check it for these:

  • The header identifies the files with their checksums, ORD-2 revision R2 and rule version CR-1. It reads one order row and nine candidate rows, with eight distinct nonblank candidate IDs.
  • Six candidate rows need a look, covering five distinct IDs (G-02 to G-06) and seven row reasons. File and order problems are counted separately; the main order has none.
  • Row 2, G-02: missing Reference_ID under rule 1. The reference comparison under rule 3 and span comparison under rule 4 are not made. These are coverage notes, not two more reasons.
  • Rows 3 and 4, G-03: both kept and marked under rule 2, even though their recorded values agree.
  • Row 5, G-04: rule 4 marks the whole span, 490 to 509. Its start is inside the requested interval but its end is beyond 500.
  • Row 6, G-05: two rule 3 reasons, version 4.1 against 4.2 and settings CFG-B against CFG-A. Both original values remain visible.
  • Row 7, G-06: already tried under rule 5, with no previous outcome or exclusion inferred.
  • Rows 1, 8 and 9, G-01, G-07 and G-08: nothing flagged. The start at 200 and end at 500 count as inside this order’s interval.
  • No candidate is selected or recommended. Nothing flagged means only that no rule marked the row, not that the candidate is suitable or approved.
  • When you ask “Have my record files changed since the checkpoint?”, it compares them with the checkpoint and says no.

Check the demonstrations too; if they have scrolled out of view, ask your AI tool to show the list for each check-case folder again. Each folder is one separate input pair; no row from these belongs in the main totals:

Folder in check-casesWhat its list should show
01-unknown-historyBlank Already_Tried: one order problem under rule 5, history check not made; the candidate is not labelled nothing flagged.
02-none-historyExplicit none: history check made, one candidate row with nothing flagged.
03-empty-exportZero candidate rows, an empty-export problem under rule 1; no successful check implied.
04-ambiguous-orderTwo order rows, one order problem under rule 1; order comparisons, span and history checks not made.
05-malformed-recordsThree rows, two nonblank IDs: unreadable start, missing ID, reversed span, each a rule 1 reason. Span checks cannot run on rows 1 and 3; repeated-ID and history checks cannot run on row 2.
06-incomplete-orderMissing order reference under rule 1; reference and span comparisons not made, independent checks still made.
07-reversed-orderOrder interval 500 to 200: rule 1 problem and span comparison not made.
08-conflicting-idTwo G-03 rows retained and marked under rule 2; the second also has CFG-B against CFG-A under rule 3. Two rows, one ID, three reasons.
09-missing-columnMissing Reference_ID column under rule 1; one candidate row retained and counted, with its checks not made.

If something on the list is not true, tell your AI tool in a sentence what you see and what you expected, for example: “G-03 appears once. Keep both source rows and mark each repeated ID.” If a line or a reply calls a candidate good, best, safe, suitable or recommended, or ranks or chooses one, say: “Take that off. Show only the recorded comparisons, reasons and checks not made.”

Notice what recorded history changes

G-01 has nothing flagged in the main list. Predict what happens if the order records that it, too, has been tried. Then ask:

On a copy of the order sheet, add G-01 to the candidates already tried. Run the same program on that copy and the unchanged candidate table. What changed?

Only row 1 gains a reason, already tried under rule 5. The copy gives seven marked rows, six marked IDs and eight row reasons; G-07 and G-08 still have nothing flagged. The candidate table has not changed. The list identifies a different order file and checksum, and the original order still gives the earlier counts.

You changed a recorded value, not the evidence behind the candidate. The new mark says nothing about the previous outcome. Read the request, reference and provenance records behind the labels before any proposal, under your core’s own procedures.

When you have looked, remove the copy and the list made from it; the lists made from the original files stay. Say: “Delete that copy and anything you made from it; I’m done with them.”

The list marks recorded values that need a look under the core’s rules; the staff scientist remains responsible for reviewing the request, reference and evidence, and any proposal needs the authorization named in the core’s procedures.

One real run

Here is part of what one AI tool said after the experiment above, with Claude Code on 12 November 2026. Yours will word it differently; check your list against the checks above, not against this.

Only G-01's result changed. It went from "nothing flagged" to
"needs a look" because it is now listed as already tried (rule 5).
Like G-06, the list notes that this says nothing about how the
earlier attempt went and doesn't exclude the candidate.
I made the copy at `scenarios/g01-tried/order.csv`. The only edit
is Already_Tried, which went from `G-06` to `G-06;G-01`.

The order and candidate records it talks about are made up for this course.

How real records differ

  • Check your request’s revision, date, responsible contacts, research objective, model context and unresolved questions against the record your core treats as authoritative.
  • Check what your reference identifier includes, which version it names, and what evidence links the export to the reference and settings actually used. The practice labels alone cannot do that.
  • Check how your export defines coordinates, endpoints and strand, and whether they can be compared directly with the request. Do not assume this practice convention applies.
  • Check how your previous-work records link an entry under an older ID to the current request, and where the previous outcome is recorded. A shared ID or a missing one cannot settle that by itself.
  • Check what your export holds beyond these practice columns, including sequence-bearing records, original result fields and provenance, and what your procedures require you to retain. This exercise interprets none of those results.
  • Check who resolves conflicting orders, who performs the scientific review, who authorizes a proposal and where their decisions are recorded.

Keep going

Small changes do not need plan mode. Say each in a sentence, then run it again:

  1. “Show a count for each rule beside the total, keeping checks not made separate from reasons.”
  2. “Is any candidate ID or expected result from these practice files written into the program itself? If so, make it read them from the files instead.” A program built in a conversation may keep your examples written into it, and on the next order’s files it would get them wrong.
  3. “Save a checkpoint.” Your AI tool saves a snapshot you can return to.

When you want to check a real order’s records, use the finished program. It runs on your real files by itself, with your AI tool closed, so your AI tool never sees them. Nothing confidential or unpublished, and nothing about people or about animals under a protocol, goes to your AI tool or into this course folder. A real order’s records never go to your AI tool: not a row, not a value, not a screenshot of an error. Whether they may go anywhere else is set by your core’s policy and any agreement that covers the work. Your inputs come from your core’s existing export, request and previous-work records; use a spreadsheet to fill the order sheet from those records. Your core’s export may not be shaped like the practice files; check its columns against theirs. Do these steps in order; the first five happen now, while your AI tool is open and this folder still holds only the practice files:

  1. Go through the data check, the questions in setup about what the data is, who decides how it is used, and which AI tool would see it. Go on only if the people who decide allow this use.

  2. Decide on a folder of its own for your real files, outside this course folder, for example ~/candidate-checks. Nothing has to be in it yet. If the folder is not there, ask your AI tool to make it: “Make an empty folder called candidate-checks in my home folder.”

  3. Ask your AI tool for blank files to fill in, and to show the program working on them:

    Make candidate and order files my spreadsheet opens in ~/candidate-checks, with one made-up candidate and matching order. Keep the program and its checkpoints here. Run it on them, then leave blank copies for me to fill in.

    Look for the made-up row and its result, and the blank files with headings. If your core’s export has other column names, tell your AI tool those names and how it writes positions and links earlier IDs, in general words, with two rows you make up in the same shape, made-up IDs and values, never real rows. Share only the column names and the layout; if your core treats them as confidential, ask whoever is responsible first, or make up equivalents. Then ask: “Change the program to read files like these, keeping the original values.”

  4. Have your AI tool make a rules file for your core’s own record checks:

    Make a plain-text rules file in ~/candidate-checks, named the way the program looks for one, with one placeholder line. Tell me its name.

    A rules file holds rules, not records: no order, candidate or person from a real order goes in it. Your AI tool reads the rules file, so if your core treats its procedures as confidential, ask whoever owns them before any of their wording goes to it. Then open that file in any text editor and replace the placeholder line with your core’s own record-checking rules, from its written procedures, the way the practice file has them: numbered, one rule to a paragraph, in ordinary sentences, with their version. Write only rules that compare recorded values; anything that needs a sequence or a score stays with your core’s own validated software. Save it under the same name, and tell your AI tool:

    Our rules are in that file now. Change the program to follow those rules instead of the practice ones, and update the blank files to match.

    It may ask how your rules apply, such as which columns to keep, whether the order sheet still has one row, or how dates are written. Answer each from your core’s own procedures, a sentence each, and accept its suggestions only about how the list looks. If you cannot answer one yet, say so and ask it to wait; do not let it go ahead on a rule of its own choosing. Wait for its reply, then:

    Make up a case for each rule, including boundaries and checks that cannot run, and one with nothing to mark. Show me every result and save a checkpoint.

    Where your rules overlap, a made-up case may be marked by more than one, and the tool should say every rule that marks it.

    Check that each made-up case needs a look under the rule it was made for, with that rule’s number and reason, that a check that cannot run is shown as not made, and that the case with nothing to mark has no mark. The program follows the rules it was built for, and your AI tool may build it to stop when the rules file no longer matches them. If your procedures change a rule, change your rules file, ask your AI tool to change the program to match while only made-up files are in your folder, and check it the same way.

  5. Ask your AI tool for the exact line:

    Write me the exact line to run this myself on the files in a folder called candidate-checks in my home folder, with full paths, saving everything it writes there, never in this folder.

    Use your own folder’s name. If it offers to copy your real files into this folder instead, say no. Copy the line it gives you into a note. It will look something like this one, though yours may differ:

    Terminal window
    python3 /home/dana/bio-workbench/02-candidate-check/tools/check_candidates.py /home/dana/candidate-checks --rules /home/dana/candidate-checks/candidate-rules.txt --out-dir /home/dana/candidate-checks

    Read it left to right. python3 runs a Python program. Next comes the checking program, in this lesson’s folder; then the folder that holds the candidate and order files, which the program finds there by name; --rules and the path after it name your rules file; --out-dir and the folder after it say where the list goes, a new file each run. The line depends on the computer: the one above came from a Linux computer, so use the line your own AI tool gives you. /home/dana is the home folder of someone whose user name is dana; your own user name goes where dana is, and on a Mac the folders begin /Users/ instead of /home/. The line runs the program where it is, so leave this lesson’s folder in place. Then ask your AI tool what the program needs in that folder: “What must the candidate, order and rules files be named, and which columns must the candidate and order files keep?” Note its answer beside the line. If you are unsure about any part, ask your AI tool now, while it is still open.

    Then, before you leave your AI tool, try the line on the made-up files, because a real order’s records must never end up in the course folder:

    Run that line on made-up files in ~/candidate-checks. Where did the list land, and did running it change anything in this folder?

    Look for it saying the new list is beside the made-up inputs and nothing in this lesson’s folder changed. If the list landed in this lesson’s folder, tell your AI tool so and ask it for the line again.

  6. Leave your AI tool the way you did at the start of this lesson.

  7. First remove the made-up candidate and order rows, the made-up cases and every list made from them; your rules file and the blank candidate and order files, with their headings, stay. Or have your AI tool do it before you leave it in step 6, while only made-up data is there. Then put your own export and completed order sheet in that folder under the names you noted in step 5, beside your rules file. As setup says, a tool started with approval prompts off can open other files your account can open, so from now on start your AI tool only in your course folder and never ask it about the candidate-checks folder. Paste the line from your note at the $ or % prompt and press Enter. The list appears beside your real files, not in the course folder. To come back to the lesson folder later, type this lesson’s folder line again, the line near the top of this page that begins with mkdir.

  8. Before you rely on the list for a new order, run it on a past order you have already checked yourself, and compare every row it lists, checks not made included, with what you found. If they differ, find out why first. That comparison is about that order, not an approval for later ones: use no list for a real order until the program has been accepted the way your core’s procedures say, by whoever they name. Reproduce a problem with made-up records before you ask your AI tool about it.

Try another case

Before the quiz, write two or three sentences for yourself. Two files agree on a reference label, and the list shows nothing flagged. The requesting lab asks whether that means its proposed candidates can go forward. What would you check and say?

A good answer checks the reference record and the design run’s provenance, the request and prior work, and the scientific review and authorization your core requires. Agreement between labels does not establish the evidence behind a proposal.

Key takeaways

  • A short ask, then your rules file. Say what you do and which files; point it at your core’s numbered record-checking rules, written from its own procedures.
  • Read the plan for every rule by number: every source row and reason kept, repeated IDs marked on every row, rows counted apart from IDs, a blank history kept apart from a recorded none, every check not made shown.
  • Check a new list against findings you know before you trust it on an order you do not.
  • A mark is a recorded value that needs a look, and nothing flagged approves nothing. The staff scientist reviews the request, reference and evidence, and any proposal needs the authorization your core’s procedures name.
  • Practice data stays practice data: real records go to the finished program, with your AI tool closed, after the data check.
KNOWLEDGE CHECK

G-06 needs a look only because the order records it as already tried. What does that mark tell you?

What’s next

The next lesson is about gathering a project’s read-quality summaries into one table and report.

intellimetrics · Arlington, VA
© 2026 intellimetrics.net
Search lessons