Sammy John Rawlinson

Markdown - An AI Superpower

2026-05-13

Markdown - An AI Superpower

Markdown - The Universal Interface

A not so long time ago (Feb 2024) I wrote a post about why I think developers should learn Git and Markdown early.

Check it out ->

https://sammyjohnrawlinson.teknabu.com/blog/Choose_Git/

At the time, the argument was fairly simple:

  • Git teaches version control and structured workflows
  • Markdown teaches structure communication and documentation.

Together they form a foundation that scales with you throughout your development.

I feel a bit prophetic about the power of markdown, as now just over a year later since the post Markdown has stopped being "just documentation"

Markdown is now one of the most important interfaces in modern computing, not because its flashy, not because it is complicated but simply:

It is readable by humans, understandable by machines, and portable across almost every modern workflow.

In the age of AI, it is a superpower to be fluent in markdown.

The Common Language of AI

One of the earliest techniques that gained traction for prompting with LLMs was using JSON. Why? Because AI works dramatically better when information is structured. A popular topic for learning AI now is Context Engineering (thats for another day)

Problem with JSON for prompting is - its not very human friendly. Every prompt took a deep thought about the problem, its not intuitive or natural.

Enter - Markdown. Why? Because Markdown gives structure to intent, it provides hierarchy, context, relationships and helps both humans and machines understanding what matters.

Once you work with AI systems regularly (or borderline intensive obsession) you realise something:

Markdown isn't just for documentation or humans anymore; it's how we communicate structured thought to AI.

Plain Text power is a "Future-Proof" Database

The biggest shift happening right now is the return of local-first computing and personal knowledge or as I like to call it "The war against the cloud".

People are discovering the fragility of proprietary platforms (I wont go over my heartbreak of Evernote and Pocket Again!!!)

Apps disappear, companies pivot, prices change, features break, platforms die.

But plain text survives.

A folder of .md files created today will be readable as long as there is computing power to switch on.

No database migration required, no vendor lock-in, no subscription needed.

This is why tools like Notion, Obsidian, Logseq have exploded in popularity

They turn a folder of .md files into a powerful networked database. Underneath all the fancy graph views and plugins is a very simple idea.

Your knowledge is just text files.

This simplicity is the feature and becomes usable eveywhere:

  • note systems
  • blogs
  • documentation
  • AI prompts
  • Git repositores
  • static websites
  • automation workflows
  • agent memory systems

What other format can do all of that well.

In my wilderness wandering post-evernote before I found the power of Obsidian(still wary of being burned again), I built my own method.

Check it out ->

https://sammy-john.github.io/note-viewer/

Documentation Became Infrastructure

Markdown has transformed software development. Living in git repositories README.md is the first document someone encounters in a project. Before installing software, running your code, or understanding what the product does they read the README .

Good documentation impacts:

  • adoption
  • onboarding
  • trust
  • maintainability
  • open-source contribution

Modern tooling has amplified this massively. Markdown can be turned into:

  • documentation sites
  • blogs
  • wikis
  • internal knowledge bases
  • technical reports

Tools Like:

  • Astro
  • Docusaurus
  • MkDocs
  • VitePress

all revolve around this idea of Content-first development.

Instead of building massive CMS platforms and complex admin panels, developers increasingly work directly with structured text files.

Most of my sites are built in this manner utilising node.js and JSON instead of databases or CMS like wordpress and its bloated plug-ins and updates.

Which leads us into a nice segway to .....

Headless CMS and Static Site Generators

I think the future of Web Development is re-inventing the past, the renaissance of static site generators.

A markdown file can now become:

  • a blog post (All my blog posts written in markdown)
  • a documentation page
  • a landing page
  • a portfolio article
  • a changelog
  • a product announcement

without needing:

  • WordPress plugins
  • MySql databases
  • complex hosting stacks
  • vulnerable admin dashboards.

This makes websites:

  • faster
  • cheaper
  • easier to maintain
  • easier to version control
  • significantly more secure

For small businesses, developers and solo operators this changes the economics of publishing online.

Markdown has its own sub-set of SuperPowers

Modern markdown is no longer a fancy text editor limited to headings and bullet points.

Mermaid.js alllows you to create diagrams directly from text to generate complex flowcharts, sequence diagrams, or Gantt charts that render natively in GitHub or Obsidian

Mathematical Typesetting: Using KaTeX or MathJax within Markdown allows developers to write complex scientiic formulas using simple text, which is essential for READMEs in data science or Engineering projects.

Tools like Quarto or Jupyter allow you to mix Markdown narrative with executable code blocks (Python, R, JavaScript), making it a superpower for technical reporting or data storytelling.

This means a document can now:

  • explain an idea
  • run calculations
  • generate graphs
  • produce reports

all from a single file.

This is evolution from formatted text into executable knowledge.

If Agents have a brain to think they need a Memory Too

This just got interesting.

The more I have been experimenting with AI Agents and local systems, Markdown has become the defacto format for agent memory and operational state (for now, apparently HTML may be changing that)

Why?

Because it is:

  • machine-readable
  • human-readable
  • appendable
  • searchable
  • version controllable

So an agent can:

  • read Markdown instructions
  • update progress logs
  • maintain project state
  • track decisions
  • leave summaries for humans
  • persist long-term context

A simple .md file can become shared memory between Humans and AI Systems.

I think big change is coming to enterprise systems trying to solve knowledge management with increasingly complicated software stacks.

Sometimes the answer is the simplest one, just structured text.

Final Thoughts

Markdown started as a lightweight formatting language, but now in the AI era it became something much bigger:

  • a publishing format
  • a knowledge format
  • a documentation standard
  • an automation layer
  • a bridge between humans and AI

that works in:

  • terminals
  • Git repositories
  • static webistes
  • note systems
  • documentation platforms
  • AI workflows
  • autonomous agents

It takes something special to survive multiple generations of computing.

Plain text did, Markdown is the interface layer built on top of it.

As my previous post said "Choose Markdown"