DEV Community: Chintan Goswami

The Hidden Cost of "Outdated Docs": How to Maintain JSDoc Without Adding Technical Debt

Chintan Goswami — Mon, 06 Jul 2026 10:55:49 +0000

Stop forcing developers to choose between shipping features and writing documentation.

Every developer has been there: You join a new project, clone the repo, open the setup guide or look at a function header, and realize... the documentation is lying to you.

Code changes in minutes. Documentation gets updated... next sprint? Never?

This documentation drift is one of the silent killers of developer velocity. It destroys the super-fast onboarding experience that scaling teams desperately need, turning clean codebases into massive piles of technical debt.

The Reality of Technical Debt

When we think of technical debt, we usually think of messy architecture or unoptimized queries. But visual and documentation debt is just as costly. Every time a developer has to guess what an undocumented (or falsely documented) utility function returns, you lose time and money.

To fix this without relying on heavy AI tools that hallucinate types, we need a deterministic, automatic documentation pipeline.

Enter `jsdoc-scribe` 🚀

Instead of making doc updates a manual chore, jsdoc-scribe automates the entire process of generating and maintaining accurate JSDoc comments directly from your codebase structure.

Why it saves your codebase:

Instant Onboarding: New hires don't have to navigate a maze of tribal knowledge; the code tells its own story accurately.
Zero Doc Drift: It ensures that your code modifications don't leave your public API documentation obsolete.
Clean Code Discipline: No external AI dependencies, no privacy concerns—just absolute, predictable JSDoc generation.

# Add it to your project
npm install jsdoc-scribe --save-dev

// before
export async function login(username: string, password: string): Promise<User> {
    const user = await db.findByUsername(username);
    if (!user) throw new AuthError("Invalid credentials");
    return user;
}

// after: gen-comments src/auth.ts --write
/**
 * @async
 * @param {string} username
 * @param {string} password
 * @returns {Promise<User>}
 */
export async function login(username: string, password: string): Promise<User> {
    const user = await db.findByUsername(username);
    if (!user) throw new AuthError("Invalid credentials");
    return user;
}

If you are looking to kill technical debt before it bottlenecks your shipping speed, check out the package below and give it a star!

👉 NPM: jsdoc-scribe on npm

We Measure Everything Except Code Quality — So I Built CodeMultiVitals

Chintan Goswami — Tue, 30 Jun 2026 08:24:36 +0000

As software engineers, we've become incredibly good at monitoring our applications.

We monitor CPU usage.

We monitor memory.

We monitor API latency.

We monitor database performance.

We monitor logs, traces, and infrastructure.

Our CI/CD pipelines run tests, security scans, dependency audits, and linters before every deployment.

Yet there's one thing we rarely monitor continuously:

The health of the codebase itself.

That realization became the motivation behind building CodeMultiVitals.

The Problem

Every project starts with clean, maintainable code.

Then reality kicks in.

New features are added.

Developers join the team.

Deadlines become tighter.

Requirements change.

Months later, the project still works—but the code becomes increasingly difficult to maintain.

You begin to notice:

Large functions
Deeply nested logic
Growing cyclomatic complexity
Duplicate code
Files nobody wants to touch
Pull requests that are harder to review
Refactoring becoming increasingly risky

These issues don't appear overnight.

They accumulate gradually.

Unfortunately, by the time we notice them, fixing them is significantly more expensive.

Existing Tools Solve Different Problems

Don't get me wrong—we already have fantastic tools.

ESLint catches code smells.
Prettier keeps formatting consistent.
TypeScript improves type safety.
Jest validates behavior.
GitHub Actions automates CI/CD.
Security scanners identify vulnerabilities.

These tools answer an important question:

"Does the application work correctly?"

But they don't necessarily answer another question:

"Is the codebase becoming healthier over time?"

Passing tests don't guarantee maintainable software.

A successful deployment doesn't guarantee sustainable architecture.

The Question That Started Everything

I kept asking myself:

Why can't every commit tell us whether the project just became healthier—or worse?

Imagine opening a Pull Request and immediately seeing:

Complexity increased by 12%
Maintainability score dropped
Three files exceeded recommended thresholds
Technical debt is trending upward
Overall project health decreased

Instead of relying entirely on opinions during code reviews, we'd have measurable engineering data.

That's exactly what I wanted to build.

Introducing CodeMultiVitals

CodeMultiVitals is an open-source code quality metrics engine for JavaScript and TypeScript.

Its goal isn't to replace existing tools.

Instead, it complements them by continuously measuring code quality across an entire project.

The current pilot version includes:

📊 Complexity Analysis
📈 Maintainability Metrics
❤️ Project Health Scores
🖥️ CLI
📦 Programmatic API
📄 HTML Dashboard
⚙️ GitHub Actions Integration
🔍 SARIF Output
🏷️ SVG Badges
📉 Historical Health Tracking

The objective is simple:

Turn code quality into measurable engineering data.

Why This Matters

Poor code quality doesn't just affect developers.

It affects the entire business.

Healthy code leads to:

Faster onboarding
Better code reviews
Easier refactoring
Lower maintenance costs
Higher developer productivity
More predictable releases
Reduced technical debt

The earlier teams identify quality issues, the cheaper they are to fix.

The Long-Term Vision

My vision extends beyond building another CLI tool.

I'd like to see continuous code quality become a standard engineering practice.

Just as every project runs automated tests before merging code, I believe every project should also answer questions like:

Is maintainability improving?
Is complexity increasing?
Are we introducing technical debt?
Which modules should be refactored first?
Is the project healthier than it was yesterday?

Code quality shouldn't be something we think about only during refactoring sprints.

It should be continuously visible.

This Is Only the Beginning

The current release is intentionally a Pilot Version.

There are many ideas planned for future releases:

Framework-specific analysis
Pull Request Quality Reports
Team Dashboards
Organization-wide Analytics
AI-assisted insights
CI/CD Quality Gates
Custom metric plugins
Trend-based quality forecasting

The goal is to build an ecosystem that helps engineering teams make better architectural decisions using measurable data.

I'd Love Your Feedback

If you work with JavaScript or TypeScript, I'd really appreciate your thoughts.

What code quality metrics matter most to your team?
Which quality problems do existing tools fail to solve?
What would make a tool like this genuinely useful in your workflow?

The pilot version is available now, and I'm actively looking for feedback from the community.

NPM: https://www.npmjs.com/package/code-multivitals

Open-source projects improve through honest discussions, and I'd love to hear your ideas, critiques, and feature requests.

Let's make code quality measurable, affordable, and part of every engineering workflow.

🚀 Released a New Version of jsdoc-scribe

Chintan Goswami — Mon, 29 Jun 2026 11:02:04 +0000

Keeping documentation updated is difficult, especially when projects continue to grow.

To make this easier, I've been building jsdoc-scribe, an open-source CLI that generates JSDoc comments and beautiful HTML documentation automatically.

The newest release includes several improvements aimed at making documentation generation faster and more reliable.

Highlights

Faster processing
Improved JavaScript & TypeScript parsing
Better HTML output
Stability improvements
Bug fixes

My long-term vision is to build one of the most complete documentation generators for modern JavaScript ecosystems.

NPM: https://www.npmjs.com/package/jsdoc-scribe

I'd love feedback from the DEV Community.

If you have ideas, feature requests, or want to contribute, let me know.

Happy coding!

Stop Writing JSDoc Comments Manually

Chintan Goswami — Mon, 29 Jun 2026 07:44:49 +0000

Documentation is one of those things every team agrees is important, but almost nobody enjoys writing.

So I built JSDoc Scribe, an open-source npm package that automatically generates professional JSDoc comment blocks.

Why?

Because developers should focus on writing software, not repetitive comments.

Features

✅ Functions
✅ Classes
✅ Methods
✅ Interfaces
✅ Variables
✅ Constants
✅ TypeScript Support

Example

Before

function calculateTotal(items) {}

After

/**
 * Calculates the total...
 *
 * @param items
 * @returns
 */
function calculateTotal(items) {}

The project is still evolving, and I'd love your suggestions.

npm: https://www.npmjs.com/package/jsdoc-scribe

GitHub: https://github.com/imchintoo/jsdoc-scribe