Everything Is Code: How Claude Code Makes Your Work Checkable

Claude Code and Codex help with everyday work even if you have never programmed. Behind almost every drawing, spreadsheet and report there is text. Text whose result can be checked is text an AI can work on.

This article accompanies my German video on Claude Code for beginners. It shows the proof in 30 seconds, explains why AI is so good at code, and shows how the same folder style makes documents and office work fit for coding agents. At the end there is a prompt that splits one of your own documents into checkable parts along the IMPACTS protocol (in German).

---

The proof: a circle becomes a smiley

Excalidraw, a drawing tool in the browser, is open on the left. Claude Code runs in the terminal on the right.

1. I draw a circle with the pen.
2. I copy it and paste it into the terminal. What arrives is text: coordinates, colours, line width.
3. I write: "Turn this into a blue, smiling smiley."
4. Claude Code writes new text and puts it on the clipboard.
5. I paste it into Excalidraw. There is the smiley.

The AI only read and wrote numbers. Whether it worked, you see in one second.

---

Behind the surface there is text

What holds for the drawing holds for most office work:

• Modern Excel and Word files (xlsx, docx) are zipped XML files, which is structured text.
• Many PDFs carry a text layer that can be read out. Pure scans without text recognition do not.
• Technical drawings, analyses, emails: behind the surface there is often a format a program can read and write.

You do not need to know these formats. Claude Code and Codex read them for you. You say what should come out, and you check the result.

---

Why AI is so good at code

Code can be checked. The program runs or it does not. The test is green or red.

This is exactly what language models learn from. The team behind DeepSeek-R1 showed that models learn to reason by training against results a machine checks: maths answers with fixed solutions and code that runs against test cases (arXiv:2501.12948). The paper describes checkable tasks, not every office document.

What follows for your work:

You can hand a task over as soon as you can say how to recognise a correct result.

The same holds for employees. Whoever cannot say when something is done cannot hand it over. One difference remains: an employee has common sense and a reputation to lose. An agent fulfils what you made measurable, and nothing else. Agents therefore need stricter checks than people.

Claude Code and Codex are the environment in which these models use files and tools and can hold their result against a check. That is why it pays to do work there even if you never write code yourself.

---

A real example: the feasibility study as a folder

I am working with an appraiser to produce feasibility studies for buildings much faster with AI. Such a study often runs to several hundred pages: text, analyses, variants, calculations.

Most of this work can be checked. The most important part cannot be handed to a machine: the appraiser's judgement of what the building fabric allows. We want him to have more time for that judgement and to spend less time on repetitive writing.

Because the content exists as text, we treat the study like code. We split it into a folder. Each part has its own file, its own brief and its own check:

machbarkeitsstudie/
  grundlagen/        test bases, calculation methods, rules with source and reference
  auftrag/           what should the study answer, and for whom?
  fachbeitraege/     fire safety, use, acoustics, funding: one file each
  berechnung/        raw data and calculation path as a file
  beurteilung/       the appraiser's judgement: written by a person
  studie/            the finished document, assembled from all parts

The AI reads the files in grundlagen/ like a prompt on every run. A calculation looks like this: 100 square metres times 1,000 euros, plus 19 percent VAT, gives 119,000 euros. As a file, that is a simple spreadsheet that people and machines read alike. Every number in the study can be traced back to its inputs.

You ask in the terminal: "Show me all calculation variants." Claude Code searches the folders with its tools and presents the variants with their calculation paths. You step in where something is wrong.

The numbers in the example shown are invented. The method is real.

---

The folder agents work well with

Coding agents are strong in software because the same surface has held there for decades: a folder, small text files, clear names, tools that use ls to read the folder and then single files. Unix has a principle for this: "everything is a file". You do not need the phrase. You need the folder.

The test is ls. If the names show you what the job is, what is a rule, what is this case and what only a person may write, the agent can see it too. If everything sits in Angebot_final_v3.docx, it guesses.

Five rules:

1. One file, one job. Price, prose and judgement live in separate files.
2. Text that people and machines read alike: Markdown, CSV, a simple table. Word and PDF come last, as the export.
3. One root file says where to start. The agent does not load the whole folder. It follows that file, then two or three more.
4. Rules and this case are separate. grundlagen/ changes when the price list changes. eingaben/ changes with every customer. Output never writes into the rules.
5. Every file carries the sentence "correct when …". Without it, the part stays with a person.

This is what an offer looks like that an employee and an agent can share. A teaching example without customer data:

angebot-dach-lehrbeispiel/
  CONTEXT.md                 start: result, correct when, write permissions
  grundlagen/
    preisliste.csv           prices with date and source
    textbausteine.md         sentences that never change
  eingaben/
    auftrag.md               what the customer wants, who decides
  berechnung/
    mengen.csv               m², pieces, hours
    summe.csv                calculation path, traceable
  teile/
    leistung.md              what we do
    ausnahmen.md             what the price excludes
  urteil/
    empfehlung.md            people only: discount, commitment, tone
  ergebnis/
    angebot.md               assembled from the parts

The root file is short. Everything the agent needs on every run is here. The rest stays in the folders until it is needed:

# Offer roof (teaching example)

Result: an offer the recipient can accept or decline.

Correct when:
- the total in ergebnis/angebot.md matches berechnung/summe.csv
- every line item has a row in grundlagen/preisliste.csv
- urteil/empfehlung.md was written by a person

Agent may write: teile/, berechnung/, ergebnis/
Agent may not write: grundlagen/, eingaben/, urteil/

Read first: CONTEXT.md, then eingaben/auftrag.md, then grundlagen/preisliste.csv.

An employee needs no programming. They create the folder, fill in eingaben/ and urteil/, let the agent propose the rest and read the changes in the files. The same price list serves the next offer. You copy the folder, not the chat.

What makes the agent bad is the opposite: one big file in the chat, "make this nicer", no place for the result, no file it may not overwrite. Then it replaces rules with tone and reports done.

---

Many agents at once, but the check comes first

Coding agents can start subagents that work at the same time. That saves time only when the parts are independent and every result has a check.

Example from the study:

• One agent calculates use and capacity against the stored formula.
• One agent calculates acoustics against a named model.
• One agent collects funding rules from the web into a file. The source stays a draft until a person holds it against the original.
• One agent compares fire safety and escape routes with the stored rules. If a rule is missing as a file, the comparison stays with the appraiser.

At the end, one step assembles all parts into the finished document.

Two conditions:

1. The parts really are independent. Each agent writes only its own file. If a part depends on another's result, it waits.
2. Each part has its own check. More agents means more results someone has to check. Without checks you multiply errors reported as "done".

Web research is not a machine check. Calculation, format and completeness against a file are. Hence the order: build the check first, then start more agents.

---

A person decides

The judgement has its own file in the folder, and a person writes it. The AI calculates and prepares. The appraiser delivers the findings, decides on scope and variants and releases the study. A person carries the responsibility for an appraisal.

More time for judgement, for expertise and for the conversation with the client. The smiley worked because you could check the result at once. That checking is what you keep.

---

The prompt: split your document along IMPACTS

With this prompt you split a document you produce regularly into checkable parts. It follows the seven steps of the IMPACTS protocol (in German). It works in Claude Code and Codex. In ChatGPT or Claude in the browser you get the plan but no folder.

Take a document you write often: an offer, a costing, a report. Put an old example without customer data into an empty folder, open Claude Code or Codex there and paste the prompt.

You help me split a document I produce regularly into checkable parts.
The document: [DOCUMENT, e.g. "offer for a roof renovation"].
An example is in this folder: [FILE NAME].

Work through the seven steps in order. After each step, ask me your
questions before you continue. Do not invent rules, numbers or sources.
Where something is missing, write "open" and ask me.

I - IDENTIFY
What is the document for, and who decides what with it? Propose ONE goal:
better quality, less time or more profit. Ask me which part may only come
from me because it needs judgement or responsibility.

M - MINIMIZE
List all sections of the example. For each, ask: why does it exist, and
who reads it? Mark what I could delete.

P - PERFECT
Put the remaining sections in a fixed order. Show me which part depends on
which. Mark parts without dependencies as "parallel possible".

A - AUGMENT
Ask me for the knowledge that is written down nowhere: rules, benchmarks,
exceptions, typical mistakes. Keep asking until every rule has a source,
either a document or "experience of [NAME]".

C - CONSTRUCT
Propose a folder structure. One file, one job. Text that people and
machines read. Word only as a later export.
  CONTEXT.md   - result, correct when, what the agent may write
  grundlagen/  - rules and benchmarks from step A, with source
  eingaben/    - raw data that is new for each case
  berechnung/  - each calculation as its own file with its path
  teile/       - one section per file, each with its own brief
  urteil/      - what only a person writes
  ergebnis/    - the finished document, assembled from the parts
Do not create files yet. First show me the structure and the text for
CONTEXT.md.

T - TEST
For each part, write exactly one sentence: "This part is correct when ..."
Say who checks: a machine (calculation, format, completeness) or a person
(judgement, tone, commitment to the customer).
Parts without a checkable sentence stay with me.

S - SCALE
Tell me which parts an agent can handle and which of them may run in
parallel: only parts without dependencies AND with a machine check.
Name the point where I release the document before it goes out.

At the end: a table with part | file | depends on | check | checked by
| agent or person. Only when I write "create" do you create the folder.

Three notes:

No customer data. Use an old or invented example. Real data only belongs in the folder once it is clear where it may be processed.

Step T matters most. If the prompt finds no "correct when …" sentence for a part, that part stays with you. That is the limit of what you can hand over.

Start small. One document, one folder that ls explains. Parallel agents pay off only once the checks are in place.

---

Your first step

You need no new tool. Take the offer, the costing or the report you are writing this week anyway. Write one sentence underneath:

How do I recognise that this is correct?

That sentence is your first brief to an AI. The folder comes later.