Keep the content as text,
keep the look in a template.

What you take back with documents is not where they live. It is how you hold the content.

2-06 set up the workshop (Forgejo and Zed). Documents go on top of it. No separate system is stood up for documents. In 2026 the places a document can live grew to three: Office, your own tools, and Claude Docs. All three are convenient, and in all three the key leans toward either someone else or you. So the first thing to decide is not where to put the document but what form to hold the content in.

Split office work three ways, by how the thing is used

What was made in Word and Excel is not one kind of thing. It is three — things you read, tables you work in, and pages you print — and each is held differently.

Which one dominates depends on the work. Statistics is mostly tables and printed pages; planning and the professions are mostly things you read; general affairs is mostly printed pages. All three are decided here, so start from the one that fits your work.

Write what is read as text, and commit only the manuscript

Writing prose in Word spends too much time on how it looks. If the text is what matters, write it as text in an editor. There are only two decisions.

First. The manuscript is AsciiDoc (.adoc) text, kept in a Forgejo repository. It is a text file, so who changed which line, and when, is recorded. Discussion of a change happens in a pull request, as with code. The editor is Zed (2-06), with the AI called from inside it. A .docx is compressed XML, so its diff cannot be read. Hold the text as text and the AI reads it and writes it directly.

Second. Commit only the manuscript; keep the design out of git. The template that decides the look lives somewhere other than the manuscript. Apply a different template to the same manuscript and it comes out in a different dress. Printing is a build of a few dozen lines the AI writes. This site itself runs that way.

manuscripts/     ← in git: only the .adoc text
  2026-09-business-report.adoc
templates/       ← the decisions about the look; kept elsewhere
  report.tmpl.adoc
output/          ← what was printed; not in git
  2026-09-business-report.pdf

With the manuscript as text, the exit is yours to choose. Print to PDF. Make HTML and put it on the site. Write out .docx when the other side needs Word. All come from the same manuscript.

Make working tables in a grid, and keep the data outside it

A table is not a thing you read. You lay it out, look, notice the odd number, cut it another way, add a note. That back-and-forth is the substance of the work, and it needs a grid on screen. So keep using a grid. Excel as before is fine, and so is Euro-Office (ONLYOFFICE) or LibreOffice, or aiseed office (aiseed-dev/officework), which is being built as an Office that is easy to use. The grid is a place to look and touch, not a place to keep things.

What you decide is what lies outside the grid.

• The data lives not in the grid but in 2-03: SQLite, PostgreSQL, Parquet
• Heavy aggregation and reconciliation go to Polars and DuckDB in 2-04
• Movement in and out of the grid stays .xlsx. Do not drop to CSV (the formatting and the formulas drop with it)

How far to push into Python depends on the person. For those who can, JupyterLab with Polars (2-04) takes the grid's place: the loop of looking at a table and cutting it another way is a cell re-run. Those who need the grid keep the grid. Push into Python as far as you can, and set the pace yourself.

Pour values into a template for pages you print

Published statistical tables, application forms, slips, invoices. These are printed on paper, and the shape of the page is itself the content. While it is being made it may be a working table; once it is to be printed, it moves here.

There is one way to hold it. The shape lives in a template, the values live as text. Pour the values into the template and put it out.

• Your own forms print to PDF from an AsciiDoc template, in the same build as the things you read
• Someone else's form (a government application, a customer's slip) is used as the template it already is, their .docx or .xlsx, and only the values go in. python-docx and openpyxl are enough, and the AI writes the code
• Reproducing their page layout on your own side is not pursued. Printing is done by their Office, or from the original PDF when the form is published as one

The work of tidying the look in a grid disappears here. Fix a value and the same template produces the same shape.

Office is not something you use, it is something you pass through

Do not misread the reason for leaving Office. This is not about efficiency. Work gets faster as a result, but that is not the point.

Split office work into three parts.

• Entrance — files that arrive from other people (Word, Excel, PDF)
• Content — where you think, work, and save
• Exit — files you hand to other people (Word, Excel, PDF)

Until now most people have done all three in Office. Word arrives, you open it in Word, edit it as Word, return it as Word. But as long as even the content lives in Office, the AI never becomes a colleague, as the next section shows.

So .docx, .xlsx, and .pptx are recast: not where the content lives, but exchange formats for dealing with people at the entrance and the exit. The organization's rules do not change. Only control of your own content comes back.

Inside Office, the AI never becomes a colleague

Why move the content out of closed formats? Because *as long as you stay inside Office, the AI remains a tool and never becomes a colleague.*

Hand a Word file to the AI and a conversion happens every time: unzip the .docx, read the XML, strip the formatting, pull out the text. Excel is the same — cell coordinates, formatting, merged cells, and cross-sheet references sit between the AI and the content.

The result is an AI you can use but not work with. Ask it to read the whole thing and sort out the issues, and the layout breaks. Ask it to analyze this table, and it stumbles over merged cells and formatted values.

The moment the content comes down to text and structured data, that wall is gone. The AI reads directly, writes directly, and returns its thinking. Office stays as an editing tool. The content, though, is kept where the AI can touch it.

From the one who processes to the one who decides

As long as you do office work inside Office, you remain the one who processes: the one who aggregates the Excel, tidies the Word, re-pastes the numbers. That work is the AI's to take, and as AI becomes cheap, organizations withdraw people from that role.

What shrinks is what was made by hand. A statistical table has a long handmade process: collect, clean, reconcile, lay out, annotate. When the AI takes that process over, the time to produce one shrinks a great deal. What is left to the person is choosing the cut and reading what the numbers mean. Closing the books is different. From journal entries to the financial statements, the accounting system already produces it. What AI shrinks there is only the handwork that remained — notes, disclosure text, reconciliation — and not as much as the statistical table. How much shrinks is decided by how much was made by hand. Look at where handwork remains in your own job, and you see where the AI bites.

A monthly sales report goes like this. The .xlsx that arrived is taken in by the machine, the aggregation is written by the AI, and the prose is drafted by the AI too. What you do is think — "which customers drove this month's growth over last month; will it continue; should the sales approach change" — and write in the interpretation and the judgment. Questions that never surfaced while you were running aggregations inside Excel stand up in front of structured local data and an AI.

Use Claude Docs as a door you pass through

Claude Docs shipped in beta on 2026-09-16. You create a document in the conversation, people edit it directly, comment back and forth, and share it, all inside Claude. As checked on 2026-10-05, it is available on Pro, Max, Team, and Enterprise.

As a place to draft, revise, and consult, it is the one with the fewest steps of anything available. At the same time, its structure is the same as Microsoft 365.

• The document itself lives inside claude.ai. It can be read only from Claude's tools
• Opening a shared link requires that the other person also have a Claude account
• On Team and Enterprise, documents cannot be shared outside the organization
• Organizations using customer-managed encryption keys, zero data retention, or a HIPAA-ready configuration cannot use it yet

One thing differs: there is a clear exit. It exports to Word, PDF, Markdown, and Google Docs. That it exports to Markdown means the manuscript can be dropped to text on your own side.

So the placement is settled. *Use Claude Docs as the place where a manuscript is drafted and circulated. Once it is final, drop it to Markdown, convert it to AsciiDoc, and commit it.* The content stays in your hands, and Claude Docs becomes a door you pass through at the entrance and the exit.

Be clear about the cost comparison too. The comparison is not with free tools. It is with what you are paying vendors now. If you commission a production company for the manuscript of your public website, compare with that one job. If you pay per-seat licenses every month, compare with that total. As of 2026-10-05, Claude Pro is $20 a month, excluding tax (2-02).

Move existing documents in, and hand things out through the exit

Documents piled up in OneDrive and SharePoint move without changing format. The .docx, .xlsx, and .pdf that arrived go into the repository as the files they are (large ones through Git LFS). No storage app for documents (Nextcloud and the like) is added. Authentication and permissions are already Forgejo's.

rclone copy onedrive:Documents ./docs/inbox --progress   # pull them out and line them up in the repository

There is no need to convert everything you already have. What you write from now on, write in .adoc from the start. *Make new manuscripts text, and the home turns over with time.* Run the migration in parallel, and cancel the old storage only after the move is done (2-12).

Sharing with business partners needs no dedicated sharing platform. What goes outside goes out through the exit: not the original file but a .docx or PDF, sent by mail (2-08). Receiving is the same — a file that arrives is opened at the entrance and then brought inside. A partner who wants to co-edit can be given an account at the gate. An exchange of versions is almost always enough.

How to check you are done

This chapter is done when these five hold.

1. You write .adoc in Zed and push, and Forgejo shows only the lines you changed as the diff
2. Both PDF and HTML come out of the same manuscript
3. An .xlsx made in the grid is read by Polars, the aggregate is written back to .xlsx, and it opens in the grid
4. Someone else's .xlsx form, with your values poured in, opens in their Excel without breaking
5. A .docx or PDF goes out to the outside through the exit

git diff manuscripts/2026-09-business-report.adoc   # only the changed lines appear
uv run python build.py                              # PDF and HTML from the same manuscript

What the human holds

Values the human supplies

• The name of the document repository, and who may read and who may edit (Forgejo's permissions)
• The template for things you read (the decisions about the look)
• The templates for pages you print (your own forms as AsciiDoc; other people's .docx / .xlsx)
• Which grid to use (Excel as before, Euro-Office, LibreOffice, aiseed office)

Actions the AI states before performing

• Converting or moving existing documents in bulk
• Sending a file with values poured into someone else's form to the outside
• Cancelling the old storage (OneDrive, SharePoint)

Versions checked, and when

• Claude Docs shipped in beta on 2026-09-16, available on Pro, Max, Team, and Enterprise; no sharing outside the organization, and not yet for CMEK, ZDR, or HIPAA configurations. Checked 2026-10-05
• python-docx, openpyxl, rclone — no version pinned
• The procedure was written on 2026-09-20 and rewritten on 2026-10-05
• If a version has moved, have the AI confirm the official procedure before proceeding

Summary

Decide not where to put the document but how to hold the content.

• Split three ways by use — things you read, tables you work in, pages you print. Which dominates depends on the work
• Things you read are AsciiDoc text — in Forgejo's git, written in Zed. The design is split off into a template and printed by a build
• Tables you work in stay in a grid — Excel, Euro-Office, LibreOffice, or aiseed office. The data lives outside the grid (2-03). The pace of pushing into Python is yours
• Pages you print pour values into a template — published tables, forms, and slips alike. Reproducing page layout is not pursued
• Office and Claude Docs are passed through — entrance and exit. A final manuscript is dropped to text and kept in your hands
• What shrinks is what was made by hand — statistical tables shrink a great deal; closing the books, much less

The next chapter puts the other big piece of office work, mail, on your own side (2-08).

Related articles

• 2-06: Bring Code In-House — Forgejo and Zed
• 2-03: Lay the Foundation — SQLite, PostgreSQL, pgvector, DuckDB, Polars
• 2-04: Write the Logic — Own Your Tools with Python and Flet
• 2-01: Becoming Independent from Microsoft and Google — The Whole Map