Coding

Getting Started with Lode Coding

@fjzeit - November 30, 2025

fjzeit.github.io/coding/lode-coding-basics

Discipline, ownership, knowledge, productivity

@fjzeit - Nov 30th, 2025 - 8 min read

What Problem Does This Solve?

When you use AI coding assistants, you’ve probably noticed something frustrating: the AI doesn’t truly know your project. It can see your code, but it doesn’t understand your architecture, your naming conventions, or why you made certain decisions. The deeper context, the stuff that lives in your head and your team’s conversations, isn’t accessible to it.

Lode Coding solves this by giving you a flexible approach to capture and share that deeper project knowledge with your AI coding assistant.

The Core Idea

Imagine having a body of knowledge about your project. One that is effortlessly created and maintained, that explains how things work, why they’re built that way, and what patterns to follow. Now imagine referencing this body of knowledge whenever you work with your AI coding assistant.

While you can recall why you made a decision in the past your AI coding assistant cannot. The lode bridges this gap by capturing knowledge from previous sessions, giving the AI access to context it would otherwise never have.

That’s Lode Coding.

The word “lode” comes from mining. A lode is a rich vein of valuable ore. Your project’s lode is a rich vein of valuable knowledge, accrued over time as you solve problems and deliver features.

What Goes in a Lode?

The coding assistant will decide what goes into the lode and you can prompt it for further refinement. A lode is a collection of markdown files (.md) organized in a folder. These files describe:

What your project does and how it’s structured
Design decisions and why you made them
Patterns you use repeatedly
How things connect to each other
Lessons learned from past problems

You don’t write these files manually. They emerge as a byproduct of your design, planning, and implementation conversations with the AI. You’re not setting out to write documentation. You’re solving problems, and the lode captures what you learn along the way.

A Simple Structure

project/
├── lode/
│   ├── lode-overview.md      # How Lode Coding works
│   ├── project-overview.md   # What is this project?
│   ├── architecture.md       # How is it organized?
│   ├── patterns.md           # Common approaches we use
│   ├── tmp/                  # Temporary planning notes
│   │   └── current-task.md
│   └── features/
│       ├── auth.md           # How authentication works
│       └── api.md            # How the API is designed
└── src/
    └── ...

Start small. You don’t need all of this on day one. Begin with lode-overview.md and a conversation with your AI coding assistant to create project-overview.md. The lode grows from there.

Discovery and Implementation

Lode Coding distinguishes between two ways of working. These aren’t about which buttons you click in your AI tool. They’re about your mindset as a developer.

Discovery

You’re investigating. You’re exploring ideas, asking questions, understanding the problem space, or evaluating approaches. Code isn’t changing yet. You’re figuring out what to do and how to do it.

Focus on discovery when you need to:

Understand how something works
Plan an approach
Weigh trade-offs between options
Research unfamiliar territory

Implementation

You’re building. The AI is proposing changes to your files, and you’re reviewing each one carefully before accepting it. You’ve already decided what to do. Now you’re doing it.

Shift to implementation when you’re ready to:

Implement a feature
Fix a bug
Refactor code
Apply a pattern you’ve already chosen

The key insight: these don’t blend. You’re either figuring things out or making changes, not both at once. Mixing them leads to sloppy decisions and code you don’t fully understand.

Some AI coding assistants have features that align with this distinction: a “planning” or “chat” mode for discovery, and an “agent” or “edit” mode for implementation. If your tool offers these, use them. But even if it doesn’t, the mental discipline of separating discovery from implementation remains valuable.

The Iteration Cycle

Discovery and implementation aren’t phases you complete once. They form a tight cycle: discover, decide, implement, update the lode, then repeat.

Work in small iterations. You don’t need to discover everything before implementing anything. Explore just enough to make a decision, implement that decision, capture what you learned in the lode, then move on to the next question. This keeps momentum high and prevents the trap of trying to plan everything upfront.

Because your lode-overview.md has introduced Lode Coding to the assistant, updating the lode is straightforward. Periodically ask the assistant to “update the lode” and it will know what to do. If the output isn’t quite right, remind the assistant that the lode files are for itself, or its future self. This sounds strange, but it improves the quality of the lode files.

The Workflow

1. Seed the Session

At the start of a session, always reference lode-overview.md first. This ensures the assistant understands what lode files are and how to work with them. Then point the AI to the relevant lode files for your task. If you’re working on authentication, reference auth.md. If you’re adding a new API endpoint, reference api.md and patterns.md.

Providing lode files before a task serves two purposes. First, it gives the assistant the context it needs to help effectively. Second, it helps you identify gaps. If the context you need doesn’t exist in a lode file, that’s a signal to create it. This might involve a discussion with the assistant about the missing topic, or an instruction for the assistant to acquire the knowledge by examining the code and asking you questions.

2. Work Through the Task

Guide the AI through the implementation. This is akin to mentoring or pairing with a junior developer, or acting like a product owner providing instruction on behaviour. Sometimes your guidance will be technical: specific patterns to follow, edge cases to handle, architectural constraints. Other times it will be about behaviours: what should happen when a user clicks this button, what the error message should say, how the feature should feel. As assistants improve, you may find yourself spending more time on behaviours and outcomes than technical details, adjusting trajectory based on what the assistant produces to ensure the results align with your technical goals. Be specific about what you want. Review what it produces and iterate to raise the technical quality.

3. Understand Everything

This is critical: never accept code you don’t understand.

If the AI produces something and you’re not sure how it works, ask questions. Have it explain. Make sure you could maintain this code yourself, because you will have to. When you commit the code, it’s yours. You’re the one responsible for the outcome, so make sure you own it.

4. Update the Lode

When you learn something new (a pattern, a decision, a gotcha), ask the AI to capture it in the appropriate lode file. This knowledge will help future sessions.

Why This Matters

You Own the Code

AI coding assistants are tools, not authors. When code goes into your project, it becomes your responsibility. Bugs, security issues, maintenance: all yours.

Lode Coding forces you to stay engaged. You’re not copying and pasting blindly. You’re reviewing, understanding, and accepting only what you’d be comfortable defending.

Knowledge Compounds

Every session adds to your lode. Over time, your AI coding assistant becomes remarkably effective because it has access to rich, accurate context about your project. The assistant will also proactively refresh knowledge when it becomes stale due to change, and add missing information as gaps are discovered.

Every new session, the AI will already know your conventions, your architecture, and your preferences.

Tools Change, Knowledge Stays

Today you might use Claude Code. Tomorrow it might be something else. Your lode is markdown files. They work with any AI tool that can read text. You can even use multiple tools simultaneously: developing on your desktop with one assistant while submitting issues for automatic completion by another. Both have access to the same rich information, and you can reference lode files in your issue text as well.

You’re not locked in. Your knowledge investment stays with you.

Getting Started Today

Create a lode/ folder in your project root
Add lode-overview.md to explain the Lode Coding approach to your AI coding assistant
Add project-overview.md with a brief description of your project
Start your next AI session by referencing these files
After the session, ask the AI to update or expand the lode with what you learned

That’s it. You’re doing Lode Coding.

The Golden Rule

Only accept what you are prepared to own.

Every line of code, every design decision, every test the AI produces should meet your standards. You should understand it, be able to explain it, and be willing to maintain it.

The AI is a powerful assistant. You are the professional responsible for the result.