Finally wrapped up my Terminal Chat (TUI) project.

NITISH Sharma — Sun, 22 Mar 2026 18:18:20 +0000

Built a real-time multi-user chat system in C++ using TCP sockets and ncurses. Multiple rooms, mentions, online users — all inside the terminal. No buttons, no mouse, just pure keyboard and questionable life choices.
I’ll be honest — I did use ChatGPT along the way. But not as a shortcut. More like a debugging partner that doesn’t get tired of my mistakes. The actual building, breaking, fixing, and understanding… that part was on me.
Also, I’ve realized something:
I genuinely enjoy building TUIs.
There’s something weirdly satisfying about making complex systems work inside a terminal. It’s not flashy, it’s not “modern UI”, and most people won’t care… but for those who live in the terminal — this is home.
This project is basically for people who:
open terminal first, browser later
think keyboard > mouse
and don’t mind staring at text all day
Click for github repo
Next step: make it more scalable and less “it works on my machine”.

I Built a Tool That Turns TODO Comments Into Actual Documentation

NITISH Sharma — Fri, 20 Mar 2026 19:50:27 +0000

Most developers already “document” their code — just not in a structured way.

We write things like:

// TODO: optimize this
// BUG: fix crash here
// NOTE: handle edge case

Over time, these comments pile up across files, and eventually… they become invisible.

I ran into this problem while working on multiple small projects. I knew I had pending work scattered across the codebase, but there was no simple way to track it without introducing another tool or workflow.

So I built DocTrack.

💡 The Idea

Instead of forcing developers to adopt a new system, I wanted to reuse what already exists inside the code.

DocTrack scans a project and extracts structured information from inline comments:

What needs to be done (TODO, BUG, etc.)
Where it exists (file + line)
What context it belongs to (code block)

The goal is simple:

Turn implicit developer notes into explicit, usable documentation.

⚙️ How It Works

At a high level, the tool:

Recursively scans a directory using C++17 filesystem APIs
Reads files line-by-line
Uses regex to detect tagged comments:

TODO
BUG
NOTE
FIXME
CODENOTE
1. Extracts:
file name
line number
message
1. Captures surrounding code context using a brace-tracking approach
2. Generates output inside a docs/ folder:
doc.md
report.html (via Pandoc)

🧠 The Interesting Part: Context Extraction

Extracting a single line is easy. Extracting meaningful context is not.

I initially tried using regex to capture entire functions, but that quickly breaks due to:

nested {} blocks
different coding styles
multi-line structures

Instead, I implemented a brace counting strategy:

When a relevant tag (like BUG or FIXME) is detected:
- Start capturing lines immediately
- Increment counter on {
- Decrement on }
Stop when braces balance

This provides a reasonable approximation of the surrounding code block without needing a full AST parser.

It’s not perfect, but it works reliably for most real-world cases.

📄 Example Output

# FILE: calculator.cpp

### Line 12 [BUG] → fix division logic

int divide(int a, int b) {
    // BUG: division by zero
    return a / b;
}

⚖️ Trade-offs

This approach intentionally avoids:

AST parsing (too complex for a first version)
language-specific parsing logic

Instead, it favors:

speed
simplicity
language-agnostic behavior

The downside:

context detection is heuristic-based
edge cases can break block extraction

🚀 Why This Approach

There are already tools for task tracking, but most require:

manual input
separate interfaces
extra discipline

DocTrack works differently:

no new workflow
no extra effort
just leverage what developers already write

🔗 Project

If you're curious or want to try it:

https://github.com/monkonthehill/doctrack

🤔 Open Questions

I’m still exploring a few directions:

Should this move toward AST-based parsing for accuracy?
Would a VS Code extension be more useful than CLI?
How to handle large codebases efficiently?

Would love to hear thoughts from others building developer tools.

📌 Final Thought

Developers already leave a trail of intent inside their code.

The real opportunity is not adding more tools —
but extracting value from what’s already there.

DEV Community: NITISH Sharma