DocX File Format Explained and Why AI Needs a Document API

Name: Why You're Still Better Than AI at Editing Documents - CS50 Tech Talk
Uploaded: 2026-04-10T14:12:33+00:00
Duration: 47 min 31 s
Channel: CS50
Description: Summary and key takeaways on DocX File Format Explained and Why AI Needs a Document API, covering The Problem with Documents Documents feel “unremarkable” to

CS50

Apr 10, 2026

•

47 min video

•

2 min read

YouTube video ID: FqB_4QY6x6g

Source: YouTube video by CS50 — Watch original video

PDF

Documents feel “unremarkable” to people—they are just the text we read and write. Yet when a file travels between Word, Google Docs, or custom applications, hidden problems appear. Inserting or deleting text can break references such as section numbers in legal contracts, and features like track changes or list numbering often disappear. The document therefore acts as infrastructure that must survive a journey across different software environments, and any loss of functionality threatens the coherence of the final product.

Technical Anatomy of DocX

A .docx file is not a single text file; it is a compressed zip folder that contains a collection of XML files. Key components include document.xml, which holds the actual content, and styles.xml, which defines formatting and defaults. XML (Extensible Markup Language) merges structure with data, so the visual appearance of a document is just a projection of this underlying source code. Word processors hide this complexity behind an abstraction layer, letting users focus on writing while the program translates edits into XML updates.

Why APIs Are Needed

Large language models such as ChatGPT, Claude, Gemini, or Co‑pilot lack a “document API.” Without a programmatic interface they cannot reliably perform deterministic actions like adding a footnote, preserving track changes, or correctly splitting a numbered list. The “Dog and Buttons” analogy illustrates the gap: an AI can generate text, but it needs specific buttons—well‑defined API calls—to manipulate the file’s internal logic. Determinism is essential for automated pipelines; the same input must always produce the same, correctly formatted output.

Superdoc: A Document API Solution

Superdoc offers an open‑source infrastructure that exposes a document API for developers. Through functions such as add_footnote, insert_clause, or apply_style, both human developers and AI agents can push precise buttons instead of trying to generate raw XML from scratch. This real‑time collaboration preserves formatting, track‑change metadata, and overall document integrity even as the file moves between Microsoft Word, Google Docs, or bespoke applications. As one speaker put it, “We’re not giving them the right interface or the right tools. We should be giving them buttons to push.”

Historical Context and Standardization

The transition from the binary .doc format to the open‑standard .docx was driven by antitrust concerns and the need for interoperability. Microsoft introduced .docx in 2006, and it became the international Open Office XML standard in 2008. The specification spans roughly 8,000 pages, underscoring the complexity hidden behind the simple “document” experience. Understanding that “a document is not just the files in a folder either, it is somehow the experience produced from those files by tools” highlights why robust APIs are crucial for the next generation of AI‑assisted editing.

Takeaways

DocX files are zip archives containing multiple XML files that define content, styles, and defaults, not simple text documents.
Human‑centric editors hide the XML complexity behind abstractions, making reliable programmatic edits difficult without a dedicated API.
Large language models cannot consistently edit DocX documents because they lack deterministic "button‑press" interfaces to manipulate the XML structure.
A document API, as demonstrated by Superdoc, enables precise actions like adding footnotes while preserving track changes and formatting across platforms.
The shift from binary .doc to open‑standard .docx, driven by antitrust and interoperability needs, resulted in an 8,000‑page specification that highlights the need for standardized programmatic access.

Frequently Asked Questions

Why do LLMs struggle with editing DocX files?

LLMs struggle because they generate text without direct access to the underlying XML structure, so they cannot guarantee deterministic changes such as correct list numbering or track‑changes metadata. Without a document API they must guess the file’s internal representation, leading to incoherent or broken documents.

What is the role of an API in maintaining document integrity during AI edits?

An API provides deterministic functions that act on the DocX’s XML components, allowing AI or code to press specific buttons like add_footnote or insert_clause. By using these stable operations, the document’s formatting, styles, and track‑changes data stay intact even when the file moves between Word, Google Docs, or custom applications.

Who is CS50 on YouTube?

CS50 is a YouTube channel that publishes videos on a range of topics. Browse more summaries from this channel below.

Does this page include the full transcript of the video?

Yes, the full transcript for this video is available on this page. Click 'Show transcript' in the sidebar to read it.

Why APIs Are Needed

Large language models such as ChatGPT, Claude, Gemini, or Co‑pilot lack a “document API.” Without a programmatic interface they cannot reliably perform deterministic actions like adding a footnote, preserving track changes, or correctly splitting a numbered list. The “Dog and Buttons” analogy illustrates the gap: an AI can generate text, but it needs specific buttons—well‑defined API calls—to manipulate the file’s internal logic. Determinism is essential for automated pipelines; the same input must always produce the same, correctly formatted output.

Helpful resources related to this video

If you want to practice or explore the concepts discussed in the video, these commonly used tools may help.

Xml Programming And Data Structures Book Recommended

Explains the XML markup language that forms the backbone of DocX files, helping the reader understand the underlying data structure discussed in the lecture.

Amazon →

Mechanical Keyboard For Software Developers

Provides a tactile and efficient interface for developers building document APIs and working with complex code structures.

Amazon →

Large Format Computer Monitor For Coding

Offers the screen real estate necessary to view complex XML schemas and document source code side-by-side with documentation.

Amazon →

Links may be affiliate links. We only include resources that are genuinely relevant to the topic.

Summarize another video

Full Transcript YouTube

Alright,
this is CS50.
My name is David Malan,
and for those of you here with us today,
unfamiliar with CS50,
it is our introduction to the intellectual enterprises
of computer science and the art of programming,
which is freely available as open courseware at CS50.edX.org.
If though you're already familiar with CS50,
welcome,
and as you might know,
we have a tradition of CS50 tech talks on occasion,
both here on campus at Harvard,
as well as via the internet.
And indeed today we're so excited to join some of our friends from Superdoc.dev.
 
In fact,
in just a moment,
you'll hear from Nick Bernal and some of the
trials and tribulations of actually really getting your hands dirty
with file formats.
In fact,
if you've taken CS50 from something like
problem set 4,
you might recall that we had you
explore the intricacies of one such file format like BMP as well as JPEGs.
For instance,
JPEGs,
a file format commonly used for photographs,
can be uniquely identified by their 1st 3 bytes,
and more,
which means Very high probability,
if you see those bytes on a hard drive or some other media,
with high probability,
do you know that that is in fact a JPEG file.
Unfortunately,
there's some file formats out there that were much more complicated,
so much so that even with today's large language models,
or LLMs in the world of AI,
it's easier said than done,
creating those files by using AI.
And so we're so happy to be joined today here
by Nick Bernal to speak to that and more
from Sudoc.dev.
Nick,
the floor is yours.
Awesome.
Hello world.
Hello everybody.
I
hope everybody's doing well.
Nice to digitally
meet everybody.
Um,
it is truly
such an
honor for me to be here.
I absolutely love CS 50.
I took this course
myself a few years ago,
um,
it's
quite a few years now,
um,
and it was so inspiring to me.
I,
I can honestly tell you.
But I still draw
so much inspiration from this class
every day
at my work and.
So thank you,
honestly
for having me and thank you for being here.
Um,
a little bit above me.
So today,
I am the director of engineering at a company called Superdoc.
When I joined the company,
we were building a contract
management product.
What does that mean?
Think
legal tech.
And
when you want to manage contracts,
You can imagine that the next thing you want to do is
create them or edit them,
right?
So,
we needed a way
to put
something like Microsoft Words functionality,
which I hope everybody's at least somewhat familiar with uh Microsoft Word,
um,
and put all of the functionality inside our own app.
And we thought
This probably exists already,
right?
I mean,
surely,
but it didn't.
Not a true DocX editor anyway.
Especially not one that we could extend and
program or build on top of.
And it had to be real Doc X.
Customers who are often lawyers,
um,
they needed
to seamlessly
move the Doc X files that they already have,
Doc X files being the Microsoft Word files.
In and out of our app
and then back to Word or to Google Docs,
for example,
which maybe some of you are more familiar with that one.
So,
We built Superdoc
and
we made it open source,
meaning
that our source code
is completely public.
And why do we do that?
Well,
this seemed like a problem
that could
be solved better by a community.
So you can actually go look at our source code right now.
You can actually go look and see about everything.
That
Superdoc is.
Literally from day one,
if you,
if you go backwards and
start browsing the commits
and
Anybody,
anybody in the world can
literally just
read the code,
understand the code,
use the code,
and
contribute the code.
Contribute to the code,
I should say.
Um,
just to be clear,
Superdoc isn't
an end user tool like Microsoft Word or Google Docs and
that you download it and you run it on your desktop.
It's not,
it's not a replacement editor.
It's actually a set of tools for developers like yourselves.
It's infrastructure for building your own
Doc X applications.
And
it is our company's entire focus.
So
Now more than ever,
software and AI
need to work with these Doc X documents too,
not just on Word or Google Docs,
but Insight.
Custom-built
applications or automation pipelines,
just everywhere.
More and more people are building more software and more systems
than ever before.
And AI is starting to participate in those systems.
And a lot of the data that actually matters.
Ends up
in documents,
right?
What?
You know,
contracts,
Or,
or,
or other,
you know,
reports and so on that they,
they need context,
they need data,
they need
information.
And when you start looking,
documents are everywhere.
They quietly shape so much of how the world works,
from our schools
and our businesses
to our careers.
Think resumes.
And the way governments operate.
So
Why documents?
Why talk about documents or doc X in a CS 50 doc?
You might think of a document as just text or a bunch of paragraphs,
lists,
headings,
and so on,
but underneath all of that,
there's actually structure,
logic,
state,
and rules
that hold it all together.
These Doc X documents are actually much closer to software than they look.
Now,
think of the last document that you created or or you edited.
Maybe it was earlier this week,
maybe you were working on an essay or an assignment,
maybe it might have been earlier today.
Maybe some of you are even taking notes in one of these apps like
Google Docs
right now.
I actually used to use Microsoft Word myself for
my math courses and used to write
my math assignments in Word because you can use the equations feature,
which is actually quite cool if you've never tried it,
give it a try.
Um
But think about it,
but just think about that experience of editing the document.
What do you remember about that experience?
I don't mean about the contents of the document,
of that last document that you
were working on.
I don't mean your ideas,
I don't mean your research or your notes.
I mean the actual experience of editing that document
with one of these applications like Google Docs.
You probably can't remember much about it,
right?
Maybe you've never even thought about it.
And that would actually mean
that these editors are working as expected.
It means that the long history
and evolution of these tools,
and they've been around for quite some time.
Has led us to a point
where the tools themselves disappear into the background,
and they let you focus on what you want to do.
To put your ideas on quote unquote paper.
And then to be able to share those ideas with
others or to collaborate on those ideas with others,
right?
Usually if you write a document unless it's just your own personal notes,
you're probably gonna share it with someone.
The process for you or I
to edit a document in something like Word
is mostly.
Unremarkable.
And it should be unremarkable.
A doc X file,
the actual file type
that
Word uses to store these documents,
feels like it should be simple too,
or at least
simple enough
that we don't even have to think about it.
And since the last time I checked,
it's 2026,
which
also means
the future.
We have this whole new set
of incredible tools available to us
that help us refine our ideas,
they help us write,
they help us edit.
They help us analyze.
Things like our friends,
the chatbots.
Think of chat GPT
Claude.
Gemini
co-pilot.
Depending on which one,
which flavor you prefer.
I'm gonna mostly refer to these as agents,
although I'll admit that's not strictly accurate,
but let's just not get lost in that right now.
Um,
these agents,
as we'll call them,
are powered by something called large language models or LLMs.
Now,
if you're not familiar with LLMs or you haven't covered the chapter in,
uh,
the AI chapter in CS 50 yet,
that's OK.
Don't worry,
you don't actually need to know
anything about
LLMs here,
in particular,
at least,
just know that they exist and there's something called a
large language model that powers something like Chat GPT.
And you probably know
what these agents are capable,
capable of firsthand anyway.
They can help you with work,
ideas,
writing,
and so on.
So let's have him help us
with a simple example.
Here I have
um
on the left,
Chaj Pit,
on the right we have Claude.
And I have this very simple document.
It's a Word document.
You can see hello CS 50.
Welcome.
And
let's just see if we can get
our
friends,
the chatbots to
do some editing with us.
So I'm gonna add the file to both.
And I'm gonna ask,
let's just start with a
real simple question.
And ask
To add a paragraph saying hello to everyone at CS 50,
using track changes.
Now if you're not familiar with what track changes are,
Microsoft Word and Google Docs have this feature,
sometimes it's called suggesting,
where
if you make a change,
Hello everyone.
It
tracks the change,
so here you can see it's.
Told you that I deleted the word welcome and I made a change here,
right,
and you can accept or reject that change,
it's actually
very powerful,
um,
standard
procedure for somebody like a lawyer,
for example,
you can accept that change or,
or not.
So
Pretty normal,
simple
operation.
So let's ask both.
Let's see if they can help us here.
They're both pondering,
and after just a moment.
Let's see what we got.
So ChaGBT came back first.
Sometimes Claude comes back first,
sometimes Cha GBT comes back first.
Um,
and ChaGBT
then show us the document.
OK,
fair enough,
it's telling us to just download the document.
OK,
fine,
let's try and do that.
So,
I've downloaded the document.
And
look at that.
It did add a paragraph.
OK,
cool.
But it's not a track change,
right?
Notice that there's no track change bubble.
I have no way to accept or reject this,
right?
So it's not really what I wanted
because if this were a contract now I suddenly wouldn't know what changed,
right?
This could be 1000 pages long and I
Wouldn't know that
this particular sentence had changed.
This particular example is very simple,
but.
So,
I didn't quite
get to what I wanted.
OK,
let's see what Claude did.
So actually Claude just saying straight up,
straight away,
I'm not able to help you here.
I'm not able to add track changes.
Option one,
do it yourself and work.
OK,
fair enough.
Um,
so
I'll,
I'll probably just
give up on clot
there for a moment.
Let's try a different one with Chai PT though,
just something a little bit more interesting,
so.
Let's take
This license agreement and I can actually maybe I should show you what the
thing looks like first.
So it looks like this
and it's a
very real,
not really very real license agreement between
Rubber Duck Incorporated.
And Superdoc Enterprises.
And if you look at the
At the list here,
number one says definitions,
license software.
And what I want
is.
To make this into a new list,
because I'm going to have multiple definitions,
other definitions,
right?
So again,
if I ask you to do that,
you can probably do it.
I just did it in
about 3 seconds,
right?
Now,
I'm gonna prompt split,
split definitions into one definitions and one A license software,
so.
Let's see what it can do for us,
you know.
Let's go to claw too,
why not?
OK,
so let's see what Chat GBT can give us here,
if it's
much help for us.
So,
this is the result from Chad GBT.
Let me actually just put it on the right,
put this one on the left.
So
It appears
it didn't do it,
right?
You can actually see license software.
OK,
so nothing really changed there.
What did it actually tell us?
Actually it's telling us that it did it,
but it didn't do it.
It didn't actually do it at all.
Now if you trusted
what you read,
you may think,
cool,
my contract has been updated.
I'm good to go.
And yet
you wouldn't be.
Right?
Now if you look at Claude,
It actually decided to
just put
this in line.
It didn't actually
put it in the document,
so I could,
I suppose I could copy and paste this.
It actually did understand what I wanted in this case.
Um,
but
it didn't actually
put it into our document.
So
you can imagine a scenario in which
one of these requests.
Could have possibly added,
for example,
just another bullet,
right,
like.
The requests were so
um ambiguous or well the request wasn't ambiguous,
the results were ambiguous,
and
you can imagine that something like this happens,
right?
And then if we read further down
our contract,
and most contracts work this way,
some other clause
is referencing Section 2A.
Well,
Now section 2A
doesn't have the same meaning anymore,
right?
So
This isn't just my contract
not really working,
this is much worse than that.
Now my contract actually is incoherent,
it,
it actually doesn't,
it's not valid anymore,
right?
So,
unfortunately,
it seems.
That these aren't really
working for us.
You can imagine what we'd really want here,
maybe.
It's an experience
something more like Word or Google Docs,
right?
Right inside the browser,
right alongside what we're doing here,
not separate from what we're doing,
but part of it.
Like all the power and simplicity of Word,
but right in the browser
with the app.
Something like this,
for example.
And this is
a full application.
It mimics a Chad GPT application,
of course it looks a little different.
But
But this one
has Superdoc in it.
This
Superdoc,
the developer tools that I mentioned,
power this application,
so you have a real editor here.
And
You can see that
earlier,
and I did this earlier just on purpose because I wanted to move this along,
um,
I prompted it the same thing,
split definitions into one
and one A.
And keep the licensed software text under 1A,
and you can see,
see the result now.
Maybe you don't actually believe me that it can do this.
So why don't we just try it?
So I'm going to reload the document.
You can see that definitions and licensed software
once again one thing.
And I'll send that prompt
And let's see if it'll do it now.
Hopefully,
sometimes these things work,
sometimes they don't.
Actually,
it did work.
So you can see it actually understood exactly what I wanted.
It did it,
and I could see it in real time,
right?
So this is more like the experience that I think we expect.
And it just works,
right?
And so,
let's explore
a little bit
about
how this is working.
Imagine that these simple examples,
uh,
imagine that actually instead of these simple examples,
you wanted to actually.
Get some help with your essays or
your resume,
something,
something important,
um.
Based on how those examples went with,
with the Chat GPT and cloud,
would you
use them?
Probably not,
right?
They didn't really help us here.
They actually made the process of editing
highly remarkable in a bad way,
but
set aside the experience of editing itself,
right?
The results themselves weren't just bad or unreliable,
they,
they were unusable.
We,
we actually can't
use those results.
So why is that?
Why is it that you or I
can do this sort of thing with such ease on Word
or Google Docs or Superdoc?
But we weren't able to perform the same simple edits
with
our friends,
the chatbots.
Let's try to unpack that question,
or.
Should I say,
unzip that question.
So,
what is a duck tax file?
We unpack
that question.
We can do it by just looking at the same original file that we had,
so let me just open that.
It's just this hello CS 50 file.
You might recall it said
welcome.
And here in my folder,
you can see it ends.docx,
right?
DOCX.
And
what this file actually is,
it's actually a folder
containing other folders and files.
What do I mean by that?
Well,
it's actually a zip file.
If you're not familiar with what a zip file is,
it just means
you take a file or you take a folder
and you can press it.
Meaning you make it,
you group it,
and then you make it a little bit smaller,
smaller,
smaller file size,
and I can prove this to you.
I can prove that this is a zip.
So if I go over to my terminal here,
and hopefully you're familiar with the terminal,
but even if you're not,
it doesn't really matter.
There's a little tool
that I can use called unzip.
I can tell it
that I want to unzip.
Hello,
CS 50.
Duck X.
And I'm gonna give it a destination.
Let's call it,
um.
Hello.
So you can see that we did something called inflating,
and then over here we have a folder called hello.
Now if I go into that folder,
this is what's inside our doc X.
You can see a bunch of folders,
a bunch of files.
And
There's a lot of things called.
XML,
right?
And you can see that if I open them,
start browsing around,
they look pretty cryptic.
But
They're still just text,
right?
And there's a lot of them.
So it turns out that our our one file has a lot going on.
And
in case you don't know,
XML
XML is a file,
is another file type,
like,
um,
David was mentioning,
I think BMP earlier.
Or JPEG or something.
Um,
XML stands for extensible
Markup Language.
And that's just a fancy way of saying plain text that combines structure and data.
It kind of looks like.
HTML if you're familiar,
you may not have gotten to that
part of CSFT yet,
but that's OK.
You've probably seen a website before,
means you've probably seen some HTML before.
Let me show you what I mean.
This tool
is also built with Superdoc,
and
what I've done here is I've taken
the same file actually this is,
this one doesn't have the welcome,
but that's OK.
And you can see here the drop down actually let me zoom in a little bit
you can probably see it a little better.
You can see that XML a little bit better formatted,
but you can see it's still pretty cryptic,
but
just a bunch of tags,
right?
You have these angle brackets.
If
now if you know HTML,
this probably starts to look real familiar.
And if I start typing on the left.
You can see
that it's changing on the right.
Right?
So
The document that you're used to.
And the editor are combining to somehow change
what looks to be sort of like source code.
And this can get pretty
complicated over here.
I mean,
this one's pretty simple,
but for example,
those track changes I was talking about,
let's say I wanna
replace this with
um.
Hello,
today,
I don't know.
Um,
you can see that all of a sudden a bunch of stuff appeared over here,
right?
There's a whole bunch of things.
And just in case you don't totally believe me that this is in fact.
The the real file that you're looking at.
I can say
hello world maybe.
And here,
I'm gonna rezip it.
Oh,
didn't go.
OK,
that's OK.
It should appear here,
that's OK.
Actually,
you know what,
let me show you something more,
more exciting,
um.
Let me go to
Different files.
So again,
there's multiple XML files.
This one's called document.
XML,
but
there's all these other XML files.
Why,
why are they there?
If you have any experience with HTML,
you can sort of think of
other files like
CSS,
although that's not really
totally accurate
representation,
but let's go with it.
So this one's called Styles,
and there's this thing called,
you don't need to understand any of these tags,
don't worry.
Um,
there's a thing called doc defaults.
I assume that means document defaults.
I can do something like.
The B tag.
Let's see,
actually,
it's not gonna let us.
Oh,
that's interesting.
Let me try it again.
Hello,
see it's 50.
Let me show you this if it'll let me do it.
Let's try it again,
WB tag.
Oh yeah,
OK,
so you can see everything on the,
on the left.
Became bold,
so the B tag and
word language
means bold,
kind of like an HTML actually.
So I've edited the document
to have a default of bold.
I can actually remove this as well.
Remove that,
I can reapply it,
you can see everything
suddenly became
not bold.
So
Our simple
XM our simple darkx file
is
not just one thing,
it's this whole zip file,
it's a whole bunch of files compressed.
It's a compressed folder.
Doc X
It's not just that one thing,
it's a combination of things,
and those things
or
XML files.
Plus a few other files that can appear in there.
I don't want to forget other files,
but we don't need to worry about those yet.
Um
The format you see on the screen when you open
that file in Microsoft Word or Google Docs or Superdoc,
right,
your editor.
And it's a sort of illusion.
It's more like a representation
or a projection.
I think about what else in CS 50
have you seen that looks a lot like this.
I would argue,
almost everything.
Think about what you build in CS 50,
your assignments.
They usually involve one or more files,
usually in a folder.
And those files by themselves are not the final thing,
they are the source.
Literally,
they are the source code.
And somewhere between those files that you write and the thing you experience,
your app,
something has to interpret them,
compile them,
render them,
or otherwise bring them to life.
If you're writing code in C.
That might be a compiler.
If you're building for the web
That might be a browser like Chrome.
In both cases,
there's a layer
between the human readable file that you write,
like say our XML.
And the final program that you actually use.
And so a document is not just the files in a folder either,
it is somehow the experience produced from those files
by tools like Word,
Google Docs,
or Superdoc.
And the reason those tools feel so natural
is that they hide the complexity that's happening underneath.
You don't have to think about the system.
You don't have to think about those files and folders and XML things.
You just write,
edit,
collaborate,
format,
bold,
and save.
That
in computer science,
is what we call an abstraction.
It is a way of hiding
lower level details.
So that you can focus on the higher level problem that you actually care about,
in our case,
your ideas,
your essays,
your resume.
And abstractions are incredibly powerful.
But they're also a kind of promise.
The promise
is that
all of that hidden complexity
is going to behave itself.
So the structure underneath.
We'll preserve what you meant.
So the document that you wrote here.
will still be the same document that someone else sees over there.
And that promise gets tested the moment the document has to move.
And most documents do move.
Most documents are made to be shared.
Or to collaborate on,
they have
to survive
a journey.
Let's take a pretty real example.
Imagine two companies
negotiating an acquisition.
Each company has their own legal team.
Each side
might also have an external law firm or some other kind of group,
maybe multiple law firms.
And within each of these groups,
so you have Company A,
you have Company B,
within each of the groups,
you're gonna have a ton of different people involved,
reviewing,
editing,
commenting,
making changes,
maybe track changes.
So what actually happens
to that document,
the document's going to get passed around,
right?
There's going to be different versions of the document,
internal,
external,
they're going to get
passed from one company to another.
And all of these people
might be in different systems like uh Windows or or Mac OS
and some might be using Google Docs and some might be using
something else.
And here's the important part.
Even when the words stay the same,
the document can change.
What if this contract that we're talking about
makes reference to some section
2A?
You might remember
That example
from here,
right?
We had some section called 2A.
Legally,
clause 2A has some specific meaning
and some specific language.
If some edit happens to that document unintentionally
that changes the list numbering.
Now referencing to A in that document has an entirely different meaning.
Think of it like a pointer in computer science terms.
A pointer doesn't hold the thing itself,
it just tells you where to find it.
And that works great as long as
what it's pointing to doesn't move,
right?
But if the underlying data shifts,
if something gets inserted,
deleted,
rearranged in some
unexpected way.
At least in our document analogy here,
the same pointer can suddenly point to the wrong thing.
The pointer didn't change
But what it means that
Suddenly,
you have a big bug in your app,
or
A big bug in your legal contract,
if you will.
Either way,
it could mean disaster.
And if documents just stayed in one app forever
and with one person,
this wouldn't really be a problem at all,
but they don't.
They move across people,
companies,
tools,
and systems.
And in that journey from system to system.
The document can start to unravel.
Let me show you a quick example
with just
Google Docs
and Word.
So,
in award,
we have this thing called fields,
and you can see that when I click
up here,
rubber duck.
It
shows a little box around it that indicates it's a field,
and I can actually,
every time I click on rubber duck,
you can see
the field,
hopefully.
Um,
like here,
right?
And one of the things this is doing is that if I change this
to say,
I don't know,
Nick
Real.
Enterprises.
You're going to see a change everywhere
in the document,
right?
So you can imagine,
this is important functionality.
But
when I upload the same thing
to
Google Docs
and I start making changes,
nothing happens.
Right,
you actually see
from a previous
demo that
It's no longer coherent,
it doesn't do the same things,
and if I were to export this and and then open it in Word,
it's not going to do the same stuff,
it,
it's lost functionality.
And this is between those two apps.
Now imagine if there were other apps that could
take away other types of functionality.
Here's one other example real quick.
This is a very fake essay.
And it's got some endnotes,
and endnotes always appear tucked
underneath
the end
of the last paragraph in the document.
But
when I opened it in Microsoft Word,
You can see that it's changed.
You can see that
there.
They're not end notes.
You can actually see that they've been split up.
There's 3 up here and 2 down here.
They're actually footnotes.
It somehow
translated them into something completely different.
And it changes my document because now my first page ends somewhere else,
my second page has a different length.
And not only that,
and I don't know if you can see this cuz it's probably really tiny,
but.
Originally
I was using.
Lowercase
Roman numerals.
Let's try zoom in.
But Google Docs has decided to change them to
real numbers,
again,
more changes.
So just going from Word to Google Docs has made a bunch of changes to my document.
And
going back,
well,
there's gonna be some more changes.
So
even with just these two,
the two most well established editors,
there's some really critical differences.
And the journey
isn't just.
Google Docs,
2
Word.
And back to Google Docs again,
right?
Or,
or vice versa,
I guess work to Google Docs and back to work.
It's
some custom app,
export it,
goes to another system,
import it,
maybe some AI edits it,
it goes back to somebody,
maybe you email it to someone and then that person has to edit
it with co-pilot and then it goes back into some other custom system and
around it goes.
And if those systems are making any changes to the document,
They better be doing so correctly
and safely.
It's not just people
Editing documents
Software
has to edit the documents too and understand them,
and not in some vague
kind of works most of the time sort of way.
It has to be reliable,
it has to be consistent.
The documents have to survive the journey.
But wait a minute.
Why do we care so much about Doc X?
Why not dot pages or .text or.
MD files?
Why do Doc X documents show up in so many places?
Well,
this didn't happen by accident.
In fact,
if you've been around documents long enough,
you may remember
that the doc X file.
But before the Doc X file,
Microsoft Word used the .doc file extension without the X.
That original
DOC or doc file
was not a zip file containing XML as a binary file,
basically
machine speak if you will,
ones and zeros.
That only Microsoft Word could read.
So we couldn't have just cracked it open and peeked inside to see what,
what was in there,
the way we did with our,
our Doc X.
But the doc X format that we've been talking
about is based on something called Office Open XML or
OOXML.
And that word open
is doing some real heavy lifting here.
Historically,
document formats weren't really
quote unquote open.
They were tightly controlled
by the applications that created them.
So if you wanted to work on a Word document,
well,
you needed Microsoft Word.
If we travel back in time for a moment
to the very long time ago of the 90s and early 2000s.
Documents became
central
to how businesses,
governments and organizations operated.
And there was increasing pressure
to make sure that documents could move between systems,
that you weren't locked into one single tool just to edit or read your own data,
your own data.
Some of that pressure was legal
because if one company controlled
the format for documents,
well,
that would mean controlling entire ecosystems around them.
And industries.
It can start to look
Like a monopoly.
And that became a big,
big deal.
Because
documents weren't just files anymore,
they were infrastructure,
and they still are.
And this is something
This is where something called
antitrust comes in.
Antitrust is about making sure one company
doesn't use its control of something like the DC X
or the DOC at the time.
In a way that harms customers or
prevents competition.
And Microsoft had already come under major scrutiny in the late 90s and early 2000s.
So there was real pressure,
including regulatory pressure,
to make document formats more open so anyone could work with them.
And
around 2006.
20 years ago.
Microsoft moved away from that old binary.DOC and
introduced the .docx format that we use today,
Doc X.
And then by 2008,
the Doc X format became an international standard,
the OpenOffice
XML standard.
Now,
Instead of a document being controlled by one application,
It became something that at least in theory,
anyone could implement.
The specification itself,
something like,
8000 pages long,
so in theory,
um,
but this is how we can even be having this conversation today.
This is why DocE documents show up everywhere.
It is quite literally
the international standard for documents.
So
Let's go back to that document journey for a second.
As documents move from tool to custom tool to another system and then back into Word,
all these tools need a reliable way to read documents,
understand them,
and change them.
If we zoom out a bit
from the narrow scope of documents
and just look at software in general,
how does software normally interact with systems and data?
Let's imagine for a second that you're building an app
that needs to send text message reminders to someone.
You're probably not going to build your own cellular network.
You're not going to figure out radio towers and cellular protocols and all of that.
Instead,
you need that cellular network to tell you how to interact with it.
Right,
they can tell you how to interact with it and they can hide their complexity.
They can just give you instructions.
Remember
those abstractions?
I mentioned earlier
The same idea shows up everywhere in software.
If you want to process a payment,
for example,
you don't need to build a bank.
If you want to
store a file,
you don't need to go build a hard drive.
If you want to send an email,
you don't need to build an email server.
And if you want to make apple pie,
you don't
need to first invent the universe.
You just need a recipe,
get the ingredients.
Make some tasty pie.
In computer science,
we give that layer a name.
We call it an API
that stands for Application
Programming
Interface.
An API
Defines a set of actions
It's a safe,
predictable way to interact with the system.
It's like a contract.
Given the same input,
you get the same result every time.
We call that
determinism.
That matters more than it might seem here,
because software doesn't just run once or make an API call,
which is
what we might say here,
which means triggering some action,
just once,
assuming people are using your software,
it happens over
and over and over,
millions of times,
and every time it happens,
it needs to behave the exact same
way.
Without that,
every interaction
becomes a guess.
Every result could be a little different.
That would not be acceptable for software,
and as we've seen,
it's not acceptable for documents either.
Think back to that experience I referred to earlier at the beginning as
unremarkable.
Yours or my experience of editing something in Microsoft Word,
the experience itself.
The reason it is or should be unremarkable is because Word,
Google Docs,
or Superdoc are purpose-built,
proven interfaces for humans
to interact with the system underneath that Doc X.
But software
needs its needs its own kind of user interface.
It needs an API.
Humans
work on documents via Word.
Software
needs to work on documents via
a document API
of sorts.
So,
earlier,
We saw that we couldn't really collaborated with Cha GPT and Claude
on our
document examples,
right?
And I've asked a question that
I've not actually yet answered.
Why is it so simple for us humans?
To edit a document in Word.
But the agents were sort of helpless here.
I hope
you're starting to see the answer to that question.
We're asking the agents to do the wrong thing,
or at a minimum,
we're asking them to do something that they can't do.
It's like asking them to make that apple pie.
Without a recipe or an oven.
Maybe you've seen
this image or a video of it before.
This exists somewhere in the world,
and it's basically a mat
with a bunch of buttons on it,
and each button
is assigned some specific word or action.
And when the dog presses the button,
it triggers sound for that particular word,
so.
People can train their dogs
to
push certain buttons depending on what
they want,
and the dog can sort of so-called speak.
So there's buttons for outside,
button for food,
button for play.
The dog isn't generating language from scratch here or it's not,
it's not even really talking,
it's just pressing buttons.
But I've
learned to press those buttons in whatever way this dog,
I think this dog's name is Bunny.
Um,
whatever way it learns best,
probably a treat,
right,
or a biscuit,
and
Each button does something really specific in a very specific way every time,
sort of like what we expect of an API.
And that's basically how you or I edit a document anyway,
right?
When you're in Word or Google Docs or Superdoc,
you're not thinking about XML or file structures
or how numbering works under the hood.
You're just doing things,
adding some track changes,
adding a footnote,
inserting into some list.
You're just pressing buttons.
And the reason that Chan GBT and Claude struggled to collaborate
with us on the document or the documents that we tried.
It's just that we're not giving them the right interface or the right
tools.
We should be giving them buttons to push.
Press this button,
add a comment.
Press that button,
create a track change.
Press this other button,
insert a footnote.
And those buttons are the API,
the document API that I mentioned earlier.
And this is,
this is a very common pattern for how all software works.
Our agents already understand this concept out of the box,
as in,
oh yeah,
I,
I see that there's a button for what my
human friend wants me to do here,
let's push it.
So we don't need AI to understand every detail of this document form,
and we don't need
it.
To generate perfect XML,
we don't
want it to try and understand thousands of pages of open XML
specifications
just to make
a simple edit.
We just needed to push the right button at the right time.
So
Why don't we try that first example again?
Or a similar example,
I guess.
But this time,
I'm gonna give the agent all the tools it needs.
I'm gonna give it Superdoc's document API
and
some instructions on how to use it.
Although,
I'm gonna
avoid customizing Chat GPT,
which one can do,
but
it's a little clunky,
and
I'm just gonna use the underlying LLM.
Remember,
LLM,
large language model,
is the thing that powers Chat GPT.
So,
I'm actually gonna use
the same
exact model
within our.
Up here
that up,
there we go.
OK,
and
So
let's see what could happen if
I give the same agent,
again,
it's this is the same model.
I don't want
to
distract from that.
I'm using Chai GPT 5.4 here
and
I'm not making the model smarter in any way.
I'm just giving you the right interface.
I'm not giving it more intelligence.
Just the right tools.
So,
let's try an example.
I'm not gonna start from the same examples from earlier,
but here we have a contract,
this particular contract is
fairly lengthy.
And what I want to do
is I actually want to insert a new clause between these two clauses.
So,
I'm gonna ask you to add a new clause called product recall liabilities.
You can see that we have assumed liabilities and excluded liabilities between.
Those two items.
And
It's gonna think just the same way Chad GBT thinks,
and it is just Chad GBT
and after a moment you can see that
it's added,
edited
the document.
But notice something interesting as well,
it
didn't just add a clause for us,
it actually followed the formatting patterns
of the clauses around it,
and this is important
because if I had asked you to do that,
you'd probably do that too.
You would have looked up
and noticed,
oh,
clause 1.3 starts with a little underline,
and so does clause,
well,
previously 1.4,
now 1.5 also starts with a little underline.
So
my clause 1.4 should probably do that too,
right?
So,
it can look and understand the context,
not just of the words.
But of the formatting of the document,
and this is critical for maintaining coherence,
readability,
and meaning
within important documents.
Let's take a look at another example,
so.
I'm gonna
open up a new.
The document here.
Waiting for Chad GBT to join us.
We go.
So,
I'm gonna ask it,
this particular,
again,
fake
example is
um
a Series A preferred stock purchase agreement.
Now,
it says the word Series A a whole bunch of times in this document.
Attempt to count how many?
Trust me,
it's many.
And I'm going to ask it
to change all instances of Series A
to Series B
using track changes.
But what I want to show you here,
and I want you to keep in mind is that
the agent is literally collaborating with us in real time.
This isn't
like the file goes somewhere and then gets changed and then I have to refresh.
So
to illustrate that,
I'm gonna send the prompt.
I'm gonna start making changes,
and then you'll see after a few moments.
That the agent actually can make the correct
changes on a changed version of the document,
so.
It's
going to get a request,
it's going to look at a document,
and then some time passes and,
and some changes have happened to that document,
and then it's going to
add its changes once,
once it figures out what to do.
So I'm asking that and then I'm just gonna start making some changes so I can
write hello,
or so the location of all of those Series A
things that I was looking for,
locations of Series A.
Have been changed.
Oh,
I didn't even caught that one.
Fascinating.
And so you can see that.
Even though I was changing the document in real time.
The agent
was able
to do the track change exactly as I asked,
and in fact you can
see now that there's a lot of Series A's changed to Series B with the track changes.
So
Me,
the human,
and the machine are collaborating together in real time.
And again,
this isn't
like I made
TGBT smarter.
It's the same Chad GPT.
I just gave it some buttons to push
the document API.
So there's a couple more examples now,
and these will get increasingly.
More fun,
I think,
hopefully,
um,
so there's this word green light capital,
one of the examples I gave earlier was.
To add
a footnote,
so let's add a footnote to Green Light Capital that says
this is a real contract.
Generally.
The type of footnote one would add to a contract,
I suppose,
and you can see that almost immediately I went added footnote.
OK,
so here we have a little number one.
And you can see that it added our footnote.
And the important thing here is,
again,
This is real Doc X.
So if I download that and I open this in work,
it really zoomed in here.
Yes.
Changes to print layout,
which I think we all probably would prefer.
You can see that all the
um track changes are there.
Our footnote is there,
our footnote is here.
This is real,
Doc X.
With an agent
This is that experience that you have when you're in Microsoft Word,
except now you're collaborating with an agent.
Again,
not by making the model smarter,
but by giving it the right
API.
Now
What if I wanted to change
the amount of money,
so I don't just want it to be,
I don't know,
what is that,
there's so many zeros,
100 million.
So this is called a round size.
Let's see if we can do it.
So,
I'm gonna ask you to change the round size to a billion.
I'm not actually even gonna type
all the zeros,
there's too many zeros,
so I'm just gonna leave it to a billion.
Let's see if you can understand what I mean by,
first of all,
by round size and
what do I even mean by billion?
Let's find out.
Um,
I look at that,
just after a moment.
And somebody can check the number of zeros for me,
but it looks correct.
It
changed around size
to a billion,
so
it's doing all of its chat GPT
things of understanding the context and understanding
intent,
as it were.
And
Applying that
in real time.
To the document.
So,
it seems that
our dog,
Bunny,
speaks after all.
Or at least
It has learned which buttons to press and when.
And so,
our humble dog hex,
now 20 years old
this year.
That's quite old
in technology terms.
In dog,
in dog years,
that'll be older.
Technology terms it's very,
very old.
Um,
our Doc X is a place
where computer science,
collaboration,
and AI are all colliding at once
today.
With real world consequences,
and I wonder beyond documents.
If we're really moving toward a world
where humans and machines are working together more and more.
Where
else are we asking them to collaborate without actually
giving them the right tools to do it well?
Where else do other systems like this exist?
Where interfaces are built for humans.
But not yet for machines.
They are likely hiding in plain sight.
Thank you very much.
That's
all I wanted to say today.
Thank you for joining us.

Watch Read Summary

Liver Lobules (Portal Triad)

Dr Matt & Dr Mike

DW Documentary

May 18, 2026

Watch Read Summary

PDF

Technical Anatomy of DocX

Why APIs Are Needed

Superdoc: A Document API Solution

Historical Context and Standardization

Takeaways

Frequently Asked Questions

Why do LLMs struggle with editing DocX files?

What is the role of an API in maintaining document integrity during AI edits?

Who is CS50 on YouTube?

Does this page include the full transcript of the video?

Why APIs Are Needed

Helpful resources related to this video

Share This Summary

Embed This Summary