AI-Native Ways of Working
Prologue / Essay
Prologue № 00 · 2026

Paperwork is Office.
Business systems are Java/C#.
But AI is Python and text.

Office for paperwork and Java/C# for business systems pair badly with AI.

2026.05.01 🌐 日本語

Much of corporate paperwork runs on Office. Business systems run on Java and C#. But AI's native language is Python and Markdown-style text.

Right there, in the AI era, runs a decisive divide.

A warning, though. Microsoft is embedding AI into that very Office and trying to "auto-pilot" the work itself. This is a business of turning the human "desire to take the easy way out" into profit — not the proper use of AI. It would be enough if Microsoft simply kept Office and AI separable, but they have no intention of doing so — AI is being wired into Office in a direction that binds them together. So this book begins by leaving Office behind.

Change your tools

OpenAI and Anthropic both run on Python. The SDKs are Python. Data is Markdown, JSON, YAML. This is not coincidence — it comes from AI's own structure.

Word files, Excel sheets, PDFs — all require conversion to text before they can be handed to AI. Each conversion drops formatting and erases structure. Existing systems in Java or C# can still be maintained with AI, but there is little reason left to choose them for new work. What runs fast in an AI-native environment is the world of Python and Markdown.

Between AI-native tools and the standard tools of the enterprise, a decisive divide runs through.

flowchart TB AI(("AI
OpenAI / Anthropic")) subgraph Native["AI-native tools"] direction LR Python Markdown JSON YAML end subgraph Legacy["Standard enterprise tools"] direction LR Office["Office
(Word / Excel / PDF)"] Code["Business software
(Java / C#)"] end Native -.->|read as-is| AI Legacy ==>|text conversion
= formatting drops, structure erases| AI classDef good fill:#e8f5e9,stroke:#7a9a6d,color:#3a4d34 classDef bad fill:#fef3e7,stroke:#c89559,color:#5a3f1a class Native good class Legacy bad

The world is already moving

The move away from Microsoft Office is not just a choice of individuals or companies — it is happening at the level of states.

In 2025, the city of Lyon, France decided to migrate from Microsoft Office to ONLYOFFICE. Germany's digital-affairs ministry announced that all public-sector documents would be in open formats only. In March 2026, a coalition of European companies — IONOS, Nextcloud, Proton, XWiki — announced Euro-Office, a project to fork ONLYOFFICE under European governance as a sovereign alternative to Microsoft Office. The first stable release ships in the summer of 2026.

Behind these moves: the U.S. CLOUD Act, geopolitical tensions, and demands for data sovereignty. From the individual to the national level, the move away from Microsoft dependence is proceeding in parallel.

What to do first

The first step is to install ONLYOFFICE and to externalize the macros, charts, and pivots embedded in Excel into Python. Order doesn't matter — pick whichever, do them in parallel.

Alongside this, one more thing — keep one AI by your side. Subscribe to one paid plan, Claude or ChatGPT. About $20 a month, and "a very capable junior clerk" works at your desk anytime. Treat it as infrastructure, like electricity or water.

No special training is required to use it. "Summarize these receipts as a table," "draft a polite reply to this email" — ask in plain language. Drop in photos, PDFs, audio by drag-and-drop. If you get stuck, ask the AI itself — the one who knows best how to use AI is AI.

And once a $20-a-month clerk arrives, a lot of things stop being necessary — Microsoft 365 ($100/yr), how-to books and business titles, industry subscriptions, specialized SaaS, outsourced work, generalist consultants. Calculate how many tens or hundreds of dollars come back to you each month against that $20. Data, knowledge, and work all return to your own hands along with the clerk.

Install ONLYOFFICE

Install ONLYOFFICE Desktop Editors (Word / Excel / PowerPoint–compatible open-source software; the community edition is free).

It installs in minutes, and from the moment it launches you can feel it runs more responsively than Microsoft Office. Word, Excel, PowerPoint all open in ONLYOFFICE. Browsing, formulas, table editing, printing, PDF export — the vast majority of daily work continues to work. Some features (macros, charts, pivots) need the externalization described below — that work proceeds in parallel.

As the first step toward leaving Microsoft Office, build the habit of working in ONLYOFFICE. With Euro-Office's stable release in summer 2026, European users and governance-focused organizations can consider migrating to it too. Both keep compatibility high.

Macros / VBA → Python (JupyterLab + Polars)

Have Claude rewrite the business logic embedded in Excel and Word as Python. JupyterLab is a "Python spreadsheet" you run cell by cell — change a value, hit Shift+Enter, see the result instantly. More readable than VBA, version-controllable in Git, testable, and AI-friendly going forward (VBA is a shrinking technology).

Charts → matplotlib / Altair

Draw Excel's charts in Python (Chapter 1, "Drawing Charts"). Keep the data in Excel; generate the charts in Python as PNG / SVG / interactive HTML. You can also paste them back into the Excel workbook as images.

Pivots → Polars

Rewrite Excel pivots as pivot() / group_by().agg() (Chapter 1, "Aggregation and Cross-tabulation with Polars"). A million rows in seconds, and the result remains as reproducible code.

What you need to run this: install JupyterLab (uv tool install jupyterlab → open jupyter lab in the browser), have Claude write the code. That's it.

With just that:

What comes after — in any order

Once Python + Claude form the base, there is no required order. Tackle whichever spot in your work is most painful, most tedious, most expensive.

Cancel Microsoft 365 and share via Git

Once macros, charts, and pivots are externalized and work runs on ONLYOFFICE, the Microsoft 365 subscription can be cancelled. Collaborative editing in Microsoft 365 becomes much more useful when replaced by Git: change history is preserved, who-changed-what-when is traceable, and conflict resolution is explicit.

Move substance to structure

Step away from UI; structure the "home" of data and logic. Details follow in later chapters:

What you can do today: install JupyterLab. That alone starts it.

The core — design structure in Markdown with AI; let AI handle the implementation

Compressed into one line, the practice of this book is:

Design structure in Markdown with AI; let AI handle the implementation.

Then: pick the structure that fits the task, and pick the tool (app / package) that fits the structure:

This is why the book introduces many apps and packages — not one all-purpose tool, but the right tool for each structure, combined.

What humans learn is the eye for structure and the eye for tool selection — that's it. No syntax to memorize. "Not the skill of writing — the skill of using." That is the new literacy.

AI's strengths and weaknesses are clear. Writing code — a language with fixed grammar and no ambiguity, the easiest medium for AI — and looking up facts are its strongest suits. What it is weak at is composition — designing a whole that takes your land, your customers, your circumstances into account. Don't hand that to AI. And one more thing: AI occasionally tells convincing lies ("hallucinations"). For anything that demands accuracy — law, medicine, finance — verify against primary sources every time. Turn the web-search feature on so the answer comes with citations, and check the source pages yourself. Treat AI's output as material — look at it calmly, revise, and use.

You think about the composition. AI gathers the facts and writes the code.

flowchart LR H(["Human"]) AI(("AI")) S["Structure
(Markdown)"] Code["Implementation
(Python / HTML / SQL / etc.)"] H <-->|design together| S AI <-->|design together| S S --> Code AI -->|writes| Code H -->|reads, judges| Code classDef human fill:#e8f5e9,stroke:#7a9a6d,color:#3a4d34 classDef ai fill:#fef3e7,stroke:#c89559,color:#5a3f1a class H human class AI ai

With this alone, nearly every domain of desk work runs the same way — writing, software development, data analysis, design, embedded. The era of learning a different tool for each specialty ends (details in Chapter 10, "Knowing What Work to Hand to AI").

Minimal stack

Independent of occupation, the toolkit you need:

Structure         : Markdown
Processing / impl : Python (Claude writes it)
Data              : JSON / YAML / SQLite / Parquet (by use, Chapter 4)
Human-viewed table: OnlyOffice (.xlsx)
Diagrams          : Mermaid
Web               : HTML + CSS + minimal JavaScript

Almost all text. AI reads and writes it directly. Still readable in ten years.

Not efficiency — quality of work and autonomy

Routine work does become several times to several tens of times faster. But that is not the goal.

Why "vendor-centralized AI" becomes a large problem

The direction Satya Nadella (Microsoft's CEO) has been pushing makes the structure plain — Microsoft is selling Copilot at the center of the message "hand it to AI, cut headcount, and profit rises." This is a sales structure that leverages the human desire to take the easy way out and make money.

The same structure shows from another angle. In June 2026, Microsoft's AI chief Mustafa Suleyman said openly of what the company pays Anthropic: "our goal is to reduce and ultimately eliminate that cost." First gather users with an excellent third-party model (Claude and the like); once the lock-in has set, silently swap the intelligence running underneath for a cheaper in-house one — counting on users being unable to leave. After the buyer has built the dependence, the substance of that intelligence can be replaced unilaterally. Before the question of not handing judgment over, there is a prior problem: you cannot know when, or to what quality, the intelligence you handed off will be swapped. This is the other face of "vendor-centralized AI" (→ Building a Microsoft 365 equivalent yourself).

The problem is that this pitch implies outsourcing judgment as well. Writing code, drafting documents, organizing data — these can be handed to AI. But what to build, which conditions cannot be traded, who carries the responsibility for the outcome — none of these can be handed to AI. AI does not take responsibility — technically, ethically, and legally, AI is not a subject that can carry it.

Yet when the pitch reads "let AI take care of it," buyers (organizations) come away feeling they have outsourced judgment, too. The result is that commonplace business systems and mediocre decisions get mass-produced, and a structure forms in which no one is responsible. The cost of failures concentrates on the buyer side (the organization, society); the seller's subscription revenue keeps flowing — moral hazard at industrial scale.

This book points the other way — use AI as a tool of execution and keep judgment and responsibility on your side. That is the ethical core of "AI-native ways of working."

Starting the work, checking the work, taking responsibility for the work — all of that stays with you. AI does the prep and the scaffolding, but the final sign-off must be your own eyes. Processing to AI, responsibility to you. Hold that line and AI remains a powerful clerk.

Not efficiency. The quality of work, the autonomy of the individual, and the diversity of society.

The free person of the AI era

The line this book has held all along — "each person holds their own tools, their own data, their own judgments" — is not a new idea. It is the AI-era form of what the "free person" who stood up out from under feudal lords more than a thousand years ago had already won: the urban citizen, the merchant, the craftsman of the free cities, and the free farmer who tilled his own land.

Why now? History textbooks credit the printing press of the 1450s with preparing the ground for the Reformation, the scientific revolution, and the modern nation-state. The LLM holds incomparably greater intensity. What the printing press democratized was "reading" (access to existing knowledge); what the LLM democratizes is "making" (knowledge generation, judgment, implementation). There is no wall of literacy to clear first — natural language works for anyone. Just as the printing press turned individuals into "readers," the LLM turns individuals into "makers and judges" — and that is the material ground that makes the "return of the free person" possible.

When the medieval free person came into being, four conditions had to converge:

Dimension Medieval freedom AI-era freedom
Economic autonomy One's own land, independent trade Building one's own back office and software with a few-thousand-yen-a-month AI; exit from SaaS and SIer dependence
Political self-governance The free cities that won their charters from lords Holding one's own data, judgment, and systems on one's own machine; exit from cloud-vendor dependence
Means of touching reality Bearing arms, growing one's own food Local LLMs, open source, one's own server; infrastructure that keeps running through blackouts and network outages
Education The seven liberal arts — grammar, logic, rhetoric, arithmetic, geometry, astronomy, music The contemporary liberal arts — judgment, verbalization, logic, systems thinking, ethics

Just as the medieval liberal arts could not stand on education alone, the contemporary liberal arts cannot stand by themselves either. Economic autonomy, political self-governance, and the means of touching reality have to be in place before the liberal arts mean anything. This is also what the chapters of this book are distributing among themselves: leave Office and Java/C# behind (tools), hold data on your own machine (political self-governance), touch reality through Python and Markdown (the means), and the eye for structure, the eye for tool selection (the liberal arts).

That aiseed.dev's sub-series comes in two threads makes sense in this same correspondence — the Software thread is the AI era's free citizens, merchants, and craftsmen; the natural-farming thread is the AI era's free farmers. The medieval free person had two forms; the AI-era free person has two as well — and a middle layer that bridges them is rising up (see below).

What this book has been arguing is not about "efficiency" or "saving money." It is about re-winning, in the AI era, the "freedom" the medieval free person won.

The future drawn by vendor-centralized AI (Copilot, ChatGPT Enterprise, Google Workspace AI) is the opposite — the contemporary form of a serf living comfortably in the lord's manor. This book heads the other way.

The middle layer — builders who hold physical reality

The medieval world also had people who lived between the pure free citizen and the pure free farmer — the stonemasons, carpenters, smiths, weavers. They held guilds, had work in both city and countryside, and had a foot in both the city's self-governance and the soil's reality. They were the craft layer that, in time, accumulated the technical capital the Renaissance was built on.

The middle layer of the AI era sits in the same structural place — inputs from physical reality (sensors, observation, material), outputs in physical reality (objects, harvests, repaired machines, buildings), with AI as the mediator doing the design and analysis, while the hand that touches reality remains a human hand.

Who belongs here:

This layer bridges the abstraction of pure software with the directness of pure physical work. Chapter 8 (embedded) and Chapter 9 (agriculture, nature, and AI) of this book are precisely about it.

The middle layer is the contemporary form of those who gain power by touching reality. The strongest form of the AI-era free person is likely to appear here.

Japan, with its deep manufacturing, town-factory, natural-farming, electronics-tinkering, and repair-culture foundations, holds a structural advantage in the move to this layer. The flow inward from both pure software and pure physical work will make it the principal mass of the new AI-era stratum.

This is the beginning of the Second Renaissance

Another name for "the return of the free person" is the Second Renaissance. The recovery of the liberal arts, the return of the polymath, the liberation of knowledge through natural language, the regeneration of the free city and the guild, the exit from vendor concentration — laid item by item, the structural changes that the First Renaissance (14th–17th centuries) drove at the end of the medieval period match those now arising in the AI era. Just as the First was brought into full force by the printing press, the Second is now being brought into full force by the LLM.

Just as the printing press broke the enclosure of the manuscript, AI breaks the wall of "the source is open, but only specialists can read it." Here the value of open source and proprietary software reverses — the advantages of closed products (polished and ready to use, with full vendor support) thin out as AI takes them over, and being open, so that you can read, fix, and grow it yourself, becomes a practical benefit for the first time. What has once gone out into the commons can no longer be recalled by anyone.

The practical methods this book lays out in each chapter — leaving Office behind, building structure in Python and Markdown, holding a local AI, keeping data on one's own machine, turning freed time toward natural farming and presence in the physical world — are the implementation manual of the Second Renaissance.

Closing

Paperwork runs on Office, business systems on Java/C#. But AI's native language is Python and Markdown-style text. Right there, in the AI era, runs a decisive divide.

Design structure in Markdown with AI; let AI handle the implementation — keep that one line, and you don't need to relearn a different culture every time the domain changes.

Migration is necessary. Doing everything in .docx and .xlsx alone is too inefficient — formatting redone every time, no code and no history, AI can't read it directly. Java and C# are the same — you can't run a single line without piling up class declarations. Drop the idea that "compiled languages are superior" — Python is a tool for running packages. Type safety belongs in structured data (JSON Schema, Pydantic, Parquet schema, SQLite constraints) and in the packages themselves (Polars, SQLAlchemy, etc.) — there is no need to load a heavy type system onto the language itself. Types are protected at the boundary between data shape and tool (close to the Linux pipeline philosophy — each part carries its types; the glue stays simple). More importantly, Java and C# struggle to handle structured data smoothly. SQLite and Parquet carry types inside the data itself (column names, types, constraints) — in Polars, pl.read_parquet(path) is one line and the types load from the file. The human doesn't look up types.

In Java or C#, by contrast:

Maintaining the data's type information as a double-ledger in your code — how inefficient this is, you stop noticing when you do it every day.

Type safety and performance are handled inside package implementations — Polars in Rust, SQLite in C, Pydantic in Rust, DuckDB in C++, NumPy in C / Fortran. The fast, type-safe compiled languages are alive inside the packages — Python users receive the benefit in one line of import. Re-implementing type discipline and performance in your own code every time is the textbook anti-pattern.

Doing everything in Excel is exactly the same shape — aggregation, formatting, pivoting, copy-paste, repeated by hand every time. What should be left to Polars / SQLite, with data types and processing moving as one. Java and C# express the symptom as a language; Excel expresses it as a spreadsheet — the disease is the same: "the work that belongs in the lower layer is being done by the human."

The depth of the Python package ecosystem is also incomparably greater. In the AI-native era, both Java/C# and Excel-centric operation are past-tense practices.

One thing per day, replace your working surface with Python and structured data.

In short — processing in Python, data in structure. Because data carries structure, AI knows how to process it, and Python — with structure-aware packages (Polars, Pydantic, SQLAlchemy, etc.) — writes the processing concisely. The triangle of "human ↔ structure ↔ AI" works under exactly this minimal condition.

The next chapter, AI (ChatGPT, Claude, etc.) Practical Manual, lays down the six tips for the ordinary person. From Chapter 2 onward, we move into specific practices, domain by domain — Python, Markdown, JSON, design, paperwork, business systems, web, apps, embedded, AI delegation, narrative verification, and the 1+AI unit.

Related

Examples

Runnable source, commands, and measured results — see the dedicated example page(s).