Treat Everything Like Code

A Decade of Evolving Thought

Over ten years ago, I started out working with data in spreadsheets — Excel, CSV — formats that were straightforward and familiar. As my responsibilities expanded, I found myself juggling not just analysis, but documentation, project plans, personal knowledge management (PKM), and even daily journaling. There was always a sense that these tasks could be approached more elegantly.

Over time, I realized the practices I applied to writing software could equally enhance how I handled everything else. Ideas like version control, branching, and continuous iteration didn’t have to stay confined to code repositories. They could guide how I organized my documents, tasks, and personal notes, turning them into systems that evolve gracefully with my changing needs.

“When everything is treated like code, work becomes a living, evolving system — always ready to be improved.”

Documentation as a Living Record

Where once I had final_v2.docx files piling up in folders, now I keep my documentation in Markdown. Unlike bulky word processors, Markdown frees me to focus on substance rather than formatting. Pairing Markdown with Git transforms documentation from static files into a living history of my thinking. Each commit is a snapshot of growth, revealing not just what changed but why.

# Service Architecture
- **Initial State:** Microservice A handles auth and data.
- **Current Revision:** Service A now delegates data processing to Service B.
- **Next Steps:** Introduce a caching layer to improve response times.

Credit https://shd101wyy.github.io

This approach is more than convenient — it’s liberating. I can experiment with new sections in a branch, review changes through pull requests, and merge updates when they feel ready. Like code, documentation becomes iterative and reliable, maintaining a clear record that anyone on my team can navigate.

Tasks as Iterative Artifacts

For years, I relied on dedicated task management apps. They looked polished but often felt isolated from my development workflow. By moving my tasks into a simple .md file and tracking them with Git, I integrate planning and doing in the same ecosystem as my code.

# Project Alpha Tasks
- [ ] Review PR #42 (backend repo)  
- [ ] Research data visualization libraries (`/docs/viz_options.md`)  
- [ ] Draft onboarding documentation for analytics pipeline

Git repository, showing a feature branch for tasks merging back into the main branch

If the project direction shifts, I update tasks alongside code changes. The result is a living task list that evolves with each commit, reflecting real progress and priorities. It’s no longer a static to-do board — it’s a narrative of how my work and focus have developed over time.

PKM and Journaling as a Growing Knowledge Garden

This philosophy extends beyond professional work into personal knowledge management and journaling. I’ve embraced Obsidian, a Markdown-based tool, to store everything from research notes to daily reflections. These notes form a connected graph of ideas, rather than isolated entries. Over time, themes emerge, insights intertwine, and the entire knowledge base matures like a codebase enriched by incremental refinements.

Not mine. Credit to Nodus Labs

Using Markdown here keeps everything lean, open, and versatile. Just as I track tasks and documentation, I commit changes to these personal notes, capturing the evolution of my thinking. And just like coding, I rely on a familiar environment — VS Code — to create and edit my Markdown files. This keeps me in a consistent workflow, switching effortlessly between writing code, updating documentation, revising tasks, and crafting my personal notes, all within the same editor. It’s a unified approach that feels natural and fluid.

Subtle Connections: Integrating AI with a Standardized Protocol

Eventually, I began exploring how to enhance this ecosystem with AI assistance. By using a standardized approach to feed context into a large language model (LLM, a “large language model”) — in my case, leveraging a protocol known as MCP (Model Context Protocol) — I ensure the model receives the right information at the right time. I don’t want to make this about any particular tool, but I appreciate how MCP quietly harmonizes the flow of data.

This setup lets the LLM understand the evolving narrative in my files, whether it’s documentation, tasks, or personal notes. When I ask, “What were the main themes in last week’s journaling?” it draws from my actual Markdown files, suggesting patterns I might have missed. If it recommends reorganizing certain notes or adjusting task priorities, I review these suggestions like a pull request, merging what helps and discarding what doesn’t.

“AI becomes a collaborator, another voice in the conversation, offering insights that sharpen over time as we iterate together.”

Iteration Through AI Collaboration

Not every AI suggestion is on target. Sometimes it misunderstands context or offers unhelpful advice. But that’s part of the process. Just as I refine code based on feedback, I refine my notes and prompts based on the model’s responses. Over time, this collaboration produces a richer, more organized body of knowledge that I can trust.

It’s exhilarating to watch an LLM suggest re-categorizing certain notes or highlight a previously overlooked connection in my documentation. This interplay of human insight and machine intelligence transforms a static archive of text into a living conversation that continuously guides me toward clarity and depth.

A Lens for All Our Work

When everything is treated like code, we embrace an evolving perspective on all aspects of work and thought. Documentation isn’t a final deliverable, tasks aren’t just isolated checkboxes, and journals aren’t dusty archives. They’re all code-like assets, open to branching, merging, refactoring, and versioning.

Over time, this approach fosters a mindset of continuous refinement. We begin to see complexity as an opportunity to iterate rather than a dead end. The result is a more transparent, adaptable, and creative ecosystem — supported by open formats, version control, and the subtle, context-aware suggestions of an AI collaborator.

A few ways to begin:

• Start by keeping one simple .md file under version control—perhaps a daily to-do list.
• Use VS Code or your favorite editor to maintain all your notes, tasks, and documentation in Markdown.
• Experiment with branching and merging — try a new organization method in a branch, then merge if it works.
• Over time, consider integrating an LLM (via a protocol like MCP) to see what insights emerge.

In the end, treating everything like code isn’t just about productivity. It’s about embracing a philosophy of openness, iteration, and growth — where every piece of text, every note, and every idea can improve, evolve, and adapt as naturally as the software we write.