DEV Community: Amritanshu Amar

I Built an AST-Based Technical Debt Analyzer Because Existing Tools Only Tell Me What, Not Why

Amritanshu Amar — Mon, 29 Jun 2026 07:38:50 +0000

Most code quality tools are really good at finding individual problems.

They'll tell you about:

Dead code
Unused dependencies
Complex functions
Large files
Style violations

These are all useful, and I use many of these tools myself.

But after working on larger codebases, I realized something was missing.

They tell me what is wrong.

Very few tools explain why a codebase is slowly becoming harder to maintain.

The Problem

Imagine opening a project and seeing this:

The analyzer tells you:

180 dead code locations
47 oversized functions
12 dependency hotspots
4 circular dependencies

That's useful.

But as a developer, my next question is always:

Why are these problems appearing?

Looking Beyond Individual Warnings

Technical debt isn't just about a long function.

Sometimes the real issue is structural.

For example:

One module becomes the dependency hub for the entire application.
Features that should be independent slowly become tightly coupled.
A single file grows because every new feature lands there.
Circular dependencies appear between modules that were originally separate.

Those patterns are difficult to notice by reading files individually.

Why I Chose AST Analysis

Instead of searching source code with regular expressions, I parse the project into an Abstract Syntax Tree (AST).

That allows the analyzer to understand:

Functions
Modules
Imports
Calls
Type definitions
Relationships between files

Rather than treating files as plain text.

What the Analyzer Looks For

The current implementation detects patterns such as:

Dead code
Oversized functions
Dependency hotspots
Circular dependencies
Complexity hotspots
Structural relationships across the project

Instead of reporting isolated warnings, it tries to build a picture of the overall architecture.

Existing Tools Are Still Great

This isn't meant to replace tools like Clippy, cargo-udeps, or SonarQube.

Those tools solve different problems extremely well.

My goal is different.

I want to answer questions like:

Why does this module keep growing?
Why does every feature touch the same files?
Which parts of the architecture are becoming bottlenecks?
Where is technical debt accumulating before it becomes obvious?

Building It

The analyzer is written in Rust and is currently part of PunamIDE.

The most interesting challenge hasn't been parsing Rust syntax.

It's been deciding which structural metrics actually represent technical debt rather than simply producing more warnings.

Finding the right balance between useful insight and information overload is much harder than building another linter.

What's Next

I'm continuing to experiment with additional architectural metrics and improving how results are visualized.

I'd also love to hear from other developers.

When you think about technical debt, what patterns do you wish your tools detected automatically?

I Built an AI IDE That Creates Automatic Safety Snapshots Before Every Change

Amritanshu Amar — Fri, 19 Jun 2026 10:01:23 +0000

Why I Started Building PunamIDE

I noticed a common problem while working with AI coding assistants.

AI can generate code incredibly fast, but one bad edit can break an entire project.

Most developers either:

Trust the AI completely
Keep making manual backups
Depend on Git commits for every small experiment

None of these felt ideal.

So I started building PunamIDE.

What Is PunamIDE?

PunamIDE is an AI-first development environment focused on safe autonomous coding.

The goal is simple:

Let AI move fast without risking your project.

One Feature That Surprised Me

Today I watched Punam SafeCode automatically create a snapshot before an AI agent modified files.

I wasn't even thinking about backups.

The snapshot happened silently in the background.

When I noticed it, I realized:

The IDE was protecting the codebase before anything could go wrong.

Current Features
AI-powered development workflow
Automatic code snapshots
SafeCode protection layer
Workspace management
Multi-agent development experiments
Local-first development
What I'm Building Next

My roadmap includes:

Autonomous coding agents
Visual project architecture
Project memory
AI-assisted debugging
AI workspace operating system concepts
Looking for Feedback

I'm still actively building PunamIDE.

What features would you want in an AI-native IDE?

I'd love feedback from developers who use:

VS Code
Cursor
Windsurf
Cline
Claude Code

I built a safety-first AI IDE in Tauri/Rust – local, free, $0 (7 months solo)

Amritanshu Amar — Wed, 17 Jun 2026 03:48:25 +0000

Yesterday, Cursor was acquired by SpaceX for $60 billion.

I've been building a free, local-first AI IDE for 7 months. Alone.
No VC money. No team. No MIT network.

This is that story.

Why I built PunamIDE

Most AI IDEs are built around one idea: code faster.

PunamIDE is built around a different idea: don't let AI break
your codebase.

After watching AI agents silently overwrite files, ignore merge
conflicts, run dangerous shell commands, and hallucinate
architecture decisions — I wanted an IDE where AI is powerful
but never unsupervised.

What makes it different

Native Snapshots — Before any AI edit, you can snapshot your
project. Named reasons: "Before AI Edit", "Before Refactor",
"Before Debugger". node_modules and dist are automatically
excluded. One click to restore.

AgentApplyGuard — Every change an AI agent proposes goes
through validation before touching your code. You see exactly
what changes, what files, what risk.

Architecture Rules Engine — A visual drag-and-drop interface
where you define layer constraints. "services CANNOT import from
ui". The IDE enforces it. No more AI casually breaking your
architectural boundaries.

Technical Debt Intelligence — AST-based analysis using
Tree-sitter. Cyclomatic complexity scoring, god class detection,
dependency cycle detection, refactor queue with time estimates.
Built in. No plugins.

3-way merge — AI can never silently overwrite your edits.
Conflict markers are generated. You stay in control.

$0 to run — Supports Gemini, Groq, OpenRouter, Ollama.
All free tiers. No subscription. No cloud lock-in.
Everything runs locally.

The stack

Built on Tauri 2 + Rust + React 19 + TypeScript.
The binary is ~15MB. Electron apps are ~200MB.

Rust handles everything heavy: filesystem, git, LSP, DAP,
PTY, AI API calls, indexing, snapshots, security validation.

The name

Punam means "full moon" in Hindi.

I named it after my late mother.

She taught me that real work is done with care, not shortcuts.
That's what I tried to build — an IDE that doesn't cut corners
on your safety.

Where it is today

Windows alpha (v2.0.0 released)
105 Rust backend tests passing
60+ UI components
LSP, DAP debugger, Git, GitHub integration, Docker panel, CI/CD monitoring, RAG workbench, multi-agent orchestration

I'm looking for 5-10 developers willing to try it and give
honest feedback. Not looking for hype — looking for real usage.

Website: https://punamide.com
Download: https://github.com/punamide/punamide-downloads/releases
Discord: https://discord.gg/PFp9KWY3eY

If you try it — thank you. Every piece of feedback matters.