Watch Claude Code Work in Real-Time: Using Markdown as Your AI Development Dashboard

If you've used Claude Code or any AI coding assistant, you know the experience: submit a prompt, watch the terminal scroll with activity, and hope everything works out. The process can feel like a black box. What if you could watch your AI assistant's progress in real-time, seeing tasks complete, code appear, and decisions logged as they happen?

In this guide, we'll show you how to transform a simple markdown file into a live development dashboard that gives you complete visibility into Claude Code's work.

The Problem with Traditional AI Coding Workflows

When working with AI coding assistants, developers often face these challenges:

• Waiting in the dark: You submit a prompt and wait, with no visibility into progress
• Information overload: Terminal output scrolls rapidly, making it hard to track what's happening
• Surprise results: You only see the final outcome, missing the reasoning behind decisions
• No progress indicators: Large tasks provide no feedback until completion

Traditional AI coding feels like:

1. Submit prompt
2. Wait...
3. Get a wall of text
4. Hope it worked

There's a better way.

The Solution: A Live Progress Markdown File

The concept is simple but powerful: instruct Claude Code to update a markdown file as it works, then view that file with a markdown reader that auto-reloads on changes. The result is a real-time dashboard showing:

• Task checklists that update as work completes
• Status messages reflecting current activity
• Code snippets appearing with syntax highlighting
• Notes explaining decisions and observations

Here's the workflow architecture:

+------------------+    updates    +------------------+
|   Claude Code    | ------------> |   progress.md    |
|   (Terminal)     |               |                  |
+------------------+               +------------------+
                                          |
                                          | auto-reload
                                          v
                                   +------------------+
                                   |  Ohai Markdown   |
                                   |  (Side Panel)    |
                                   +------------------+

Setting Up Your Real-Time Dashboard

Step 1: Create a Progress Tracking File

Create a progress.md file in your project directory with sections for tracking:

# Project Development

> Building [your project description]

---

## Tasks

- [ ] Create project structure
- [ ] Implement core logic
- [ ] Add CLI interface
- [ ] Write tests
- [ ] Create documentation

---

## Current Status

**Status**: Ready to begin

*Waiting for first prompt...*

---

## Code Generated

*Code will appear here as it's created...*

---

## Notes

*Decisions and observations will be logged here...*

Step 2: Create Instructions for Claude Code

Add a CLAUDE.md file (or include in your existing project instructions) that tells Claude Code how to update progress:

# Claude Code Instructions

## Critical Instruction

After completing each task, update `progress.md` to reflect your progress.

## How to Update progress.md

### 1. Mark tasks complete
Change `- [ ]` to `- [x]` as you finish each task.

### 2. Update Current Status
Replace the status section with what you're doing now.

### 3. Add Code to Code Generated section
Show key code snippets as you create them.

### 4. Log decisions in Notes
Document your reasoning and observations.

Step 3: Open the Dashboard

Position your windows for optimal visibility:

# Open the progress tracker in Ohai Markdown Reader
open -a "Ohai Markdown Reader" progress.md

# Position Ohai alongside your terminal
# Terminal: left 60% of screen
# Ohai: right 40% of screen

Step 4: Start Claude Code with Progress-Aware Prompts

When giving prompts to Claude Code, remind it to update progress:

Create the project structure for our application.
Update progress.md as you work.

What You'll See in Real-Time

As Claude Code works, watch your markdown dashboard come alive:

1. Task checkboxes filling in: Each [ ] becomes [x] as work completes
2. Status updates: See messages like "Implementing core logic..." change in real-time
3. Code blocks appearing: Watch syntax-highlighted code populate the document
4. Notes accumulating: Read Claude's decision-making process as it happens

The experience transforms AI-assisted development from a black box into a transparent, observable process.

Practical Example: Building a CLI Tool

Here's a real-world scenario demonstrating the workflow. You're building a CSV to JSON converter:

Prompt 1: Setup

Create the project structure for our CSV to JSON converter.
Update progress.md as you work.

Watch in Ohai: The "Create project structure" task checks off, status changes to "Setting up project...", and the directory structure appears.

Prompt 2: Core Logic

Implement the CSV parsing and JSON conversion logic.
Show the key code in progress.md as you write it.

Watch in Ohai: Code blocks appear with Python syntax highlighting, two tasks check off, and notes explain the design approach.

Prompt 3: Testing

Write unit tests for the converter. Show test examples
in progress.md and run them to verify they pass.

Watch in Ohai: Test code appears, results show in the output section, and the testing task completes.

Key Benefits of Real-Time Progress Tracking

Catch Issues Early

When you can see what Claude Code is doing, you can interrupt early if something goes wrong. No more waiting for a complete implementation only to find it went in the wrong direction.

Stay Engaged and Informed

Instead of passive waiting, you're actively following the development process. This keeps you in the loop and helps you understand the generated code better.

Better Collaboration

The progress file serves as a log of what was done and why. This is valuable for team discussions, code reviews, or revisiting decisions later.

Reduced Anxiety

Knowing what's happening at each step reduces the uncertainty that comes with AI-assisted development. You can see progress is being made.

Tips for Best Results

1. Position windows side-by-side: Terminal on the left, markdown viewer on the right
2. Use a markdown reader with auto-reload: The file must refresh automatically on save
3. Structure your progress file clearly: Use headers, task lists, and code blocks
4. Include explicit update instructions: Remind Claude Code to update the file in each prompt
5. Watch the checkboxes: They're the most satisfying visual indicator of progress

Try It Yourself

Ready to transform your Claude Code experience? The real-time progress tracking workflow requires just three things:

1. A structured progress.md file
2. Instructions for Claude Code to update it
3. A markdown viewer with auto-reload capability

Ohai Markdown Reader is purpose-built for this workflow. It automatically reloads files when they change, renders task lists beautifully, and provides syntax highlighting for code blocks. Download it free and start watching your AI assistant work in real-time.

Stop waiting in the dark. Start seeing exactly what Claude Code is doing, as it happens.

---

Want to try the complete demo? Check out the Claude Code demo package with ready-to-use progress files and prompts.