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 - 10 min read

Note: This article was updated on 27 Jan 2026 to cover a stepwise improvement in the approach. The lode-overview.md has been removed and replaced with a system prompt which you can either append on the command line or add to an AGENTS.md or equivalent. The system prompt has been refined to mostly automate the lode method. You no longer need to manually source files to seed the session. Additionally, the agent will find relevant lode documents when it requires them.

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
Useful Historical gathered during sessions

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.

The Lode Structure

The coding agent will create this if it does not exist. It will also populate and maintain the lode content. You do not have to do anything other than ensure that you enrich your agent via one of the following methods:

using the claude script in the lode repo
placing the contents of SystemPrompt.txt in your project’s AGENTS.md (or vendor-specific equivalent)

A typical baseline structure that the agent will create looks like this:

project/
└── lode/
    ├── summary.md            # What is this project?
    ├── terminology.md        # What is this project?
    ├── practices.md          # Patterns and practices relevant to this project
    ├── lode-map.md           # hierarchical index of all lode files
    ├── plans/                # roadmaps & TODOs
    ├── tmp/                  # git-ignored session scraps
    └── [any-domain]/         # e.g. parser/, auth/, ui/, billing/
        └── summary.md + *.md # one focused topic per file (kebab-case)

The structure and content will grow as you orchestrate development.

Conversational Orchestration

Conversational orchestration is key to the success of this method. You converse with the agent as if you were pairing or mentoring a junior or mid-level colleague. A unique colleague at that, one who types extremely fast, has considerable knowledge of languages, protocols, and other theory, but lacks any experience in building quality sustainable software and is prone to making foolish mistakes.

Converse with the agent in this manner and you will naturally provide the level of detail required to enrich the session, resulting in more productive output and high quality information placed in the lode.

Planning

Instead of writing markdown files up front, behave like you would if you were coding organically. Ensure you have a good understanding of the requirements, a reasonable idea about the overarching design, and a mental list of steps you plan to implement, as well as the checkpoints you’ll use to verify results.

Conduct a two-way conversation with the agent as if it were a colleague. Explain the problem, your vision, plan, and other pertinent details. The two-way conversation is important because you receive feedback from the agent about its understanding and the opportunity to correct it. This is considerably more effective than up-front detailed hand-written markdown.

If your agent has a planning mode you should use it for this step as it will result in a comprehensive plan you can review before starting.

When the agent presents you with a plan you should review it and provide feedback, ask clarifying questions, and if necessary continue the conversation to raise the quality of the plan. No different to mentoring a colleague.

Once you’re happy. It’s time to implement.

Implementation

This phase has become a lot simpler since Q4 2025 when agents and models seemed to take a dramatic step forward in ability. In the following I will present the more controlling approach but you should find that you can relax a little more and leverage the benefits of these new agent and model capabilities.

By now you should have been presented with a plan. One that maps well to the vision and instruction you provided during planning. *This is not the time to go grab a cup of tea*. This is the time to work.

Our primary goal is to ensure we have quality, maintainable, and acceptable code by the end of the session. No long rework, no manual refactors or clean up.

Keep your agent’s permissions as tight as possible. How tight is going to depend on the complexity of the work at hand, your comfort with the lode coding method, and your level of trust with the model and agent.

Watch the agent as it works
Review every file change
Intervene when appropriate

Intervention is important. If you see the agent start to do something that is unacceptable, hit the ESC key and have a pep talk with it. This might involve asking it what it’s doing, or it might just be a straightforward correction.

Correcting via conversation is important in lode coding. The agent will automatically update the lode on completing work. So it’s important that any clarifications or direction changes are provided to the agent if you want those retained for future sessions.

The Iteration Cycle

Planning and implementation aren’t phases you complete once. They form a tight cycle: plain, decide, review, implement + intervene, repeat. The agent will automatically update the lode as it goes.

Work with small incremental changes. Avoid trying to one-shot anything, especially entire features. Work to your own pace. Don’t let the marketing hype push you into trying to 100x your work. Speed is an inherent properly of coding agents, but your primary goal here is to retain full understanding of the code and to enforce a level of quality that encourages sustainability and changeability.

Session Handover

Sometimes its helpful to move an implementation to a fresh session. To do this simply ask the agent to create a handover lode. It will then create a lode in lode/plan/ and leave handover instructions for the next session. You can resume a handover by simply mentioning the handover file in your first prompt:

   resume from lode/plans/name-of-handover.md

It’s useful to not include an @ prefix when doing this.

Lode Maintenance

From time to time you will want to conduct a lode audit. You can do this by simply asking the agent:

audit the lode and ensure it correctly describes the system as implemented

The agent will conduct an interactive review with you and update the lode.

Merging

As far as merging goes, the agent is quite capable of looking at the two branches and reconciling the lode after you have conducted the merge. If you have any lode merge conflicts, just accept the incoming changes and then explain to the agent that it should resolve any inconsistencies in the lode. Provide helpful information relating to relevant branches or commits. The agent will do most of the work for you and verify the lode is correct.

Existing Projects

Lode Coding works with existing projects. When you start a lode coding session the agent will attempt to read the lode. If the lode does not exist, it will ask you if it can create one. Accept this request. The agent will examine the project and create the baseline lode structure.

If your project is relatively small the agent might then add additional lode files to give itself full coverage but in most cases it will suggest updating the lode as it goes.

If you want a full lode created you can simply ask the agent for one. Large lode creation is better done in phases so be sure to enter planning mode and have the agent work in tranches. Create a fresh session for each tranch. Also, watch your token usage. :)

Additional Thoughts

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 not feeding in a markdown requirements document and hoping for the best. You’re undertaking context management, then 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 regardless of what tooling you use.

Getting Started Today

Visit the Lode Coding Repo and either clone it and run the lode script to start, or grab the System Prompt and save it in your AGENTS.md

That’s it. You’re ready to Lode Coding.