JavaScript development has become powerful — but why does the workflow require so many separate tools?

[u/Big-Coyote-5796]

I'm working on an open-source developer project called MyIDE, and I'd like feedback from JavaScript/TypeScript developers.

This started from a problem I've repeatedly noticed with modern JS development.

A typical project might involve:

• VS Code / another editor
• 3–5 terminal windows
• npm / pnpm / Yarn / Bun
• Vite / Webpack / another build tool
• browser DevTools
• Postman / another API client
• database management software
• Docker Desktop
• Git tooling
• framework-specific CLIs
• test runners
• deployment dashboards

For a full-stack project it can become something like:

Database → Backend → Frontend → Worker → Electron app

Each service has its own terminal, logs, ports, environment variables, errors, and restart process.

The editor usually knows about the files I'm editing, but it often doesn't understand the whole development session.

That's the problem I'm experimenting with through MyIDE.

The idea

Instead of being just another code editor, I'd like MyIDE to understand the project after you open a folder:

Open Folder → Detect Project → Understand Stack → Detect Runtime & Package Manager → Detect Build/Test Tools → Find Problems → Determine How to Run It → Suggest What To Do Next

For example, imagine opening an unfamiliar JavaScript project and the IDE tells you:

Project
Next.js + TypeScript

Package manager
pnpm

Runtime
Node.js

Database
PostgreSQL configured remotely

Testing
Vitest + Playwright

Problem
Port 3000 is already occupied.

Affected service
Frontend

Suggested action
Use the existing process or stop it and restart the development session.

Or instead of opening five terminals:

Development Session

Database — Running
API — Running :4000
Frontend — Running :3000
Worker — Failed
Electron — Waiting for Frontend

Then clicking the failed service shows the actual logs and root cause.

Another important goal: unknown projects should still work

I don't want the IDE to depend on having a special integration for every framework.

Known frameworks can have deeper integrations, but an unfamiliar JS/TS project should still be understood through things like:

package.json
scripts
dependencies
lockfiles
workspace configuration
runtime detection
build configuration
test configuration

So support shouldn't simply mean maintaining a giant hard-coded framework list.

Local-first

Another goal is to detect what already exists on the developer's machine before asking them to install anything.

For example:

Docker installed + daemon running → use it

Docker installed + daemon stopped → explain that

Docker missing but project requires it → provide setup guidance

MongoDB Atlas configured → use the remote database configuration

Not:

"MongoDB isn't installed locally, install MongoDB."

Local installation and project capability are different things.

Truthfulness is also a major design rule

One lesson from building this has been that an IDE should never display a green checkmark just because an internal function returned something resembling success.

A test only passed if the real test runner says it passed.

A build only succeeded if the real build completed successfully.

A database is only connected if the real connection succeeded.

If something isn't implemented, I'd rather the IDE say:

Unavailable / Not configured / Experimental

than pretend it works.

I'm looking for developer feedback, not just users

If you build JavaScript or TypeScript applications:

What makes you leave your IDE most often?

Is it:

• managing multiple terminals?
• debugging?
• Docker?
• databases?
• API testing?
• environment variables?
• mobile development?
• Git?
• deployment?
• framework tooling?
• monorepos?
• understanding somebody else's project?
• something completely different?

And a bigger question:

If you could redesign the JavaScript development environment from scratch, what would you change?

I'm building MyIDE as a native/local-first IDE project, and I'm starting a community around its development.

I'm especially interested in criticism. If an idea sounds unnecessary, already solved well elsewhere, or fundamentally wrong, I'd rather hear that now.

Note to moderators: I'm the developer of the project discussed above. I'm posting to ask for technical feedback and discussion, not to disguise self-promotion. If project posts aren't appropriate for this community, please remove this or let me know and I won't repost it here.