Making backend scaffolding AI-native with natural language + MCP support

[Akshay1018]

🏷️ Discussion Type

Product Feedback

💬 Feature/Topic Area

Other

Body

I’ve been exploring a problem a lot of backend developers face: the repetitive setup work that happens every time you start a new service.
Even with good boilerplates, we still spend significant time choosing frameworks, configuring databases, setting up auth, writing CI pipelines, adding Docker, and applying basic security defaults. Most of this work is predictable, yet we keep doing it manually.

I’m building an open-source CLI called Trove to address this. Currently, it supports scaffolding production-oriented Node.js backends with Express, NestJS, Fastify, or Koa, along with database, authentication, testing, CI/CD, and Docker options.

But the more interesting direction is making it AI-native:

• Allow developers to describe the backend they want in natural language
• Convert that into a structured, validated project plan grounded in actual supported capabilities
• Generate the project using deterministic templates
• Eventually expose this through MCP, so AI coding agents can use Trove as a reliable scaffolding tool

I’m particularly interested in feedback on a few open questions:

• How valuable is natural-language project planning versus a traditional interactive CLI?
• What level of automation would you actually trust (especially around file writes and dependency installation)?
• Should MCP support focus only on scaffolding, or also include validation and light repair workflows?
• What makes a generated starter project genuinely useful instead of something people immediately rewrite?

Repository: https://github.com/Akshay1018/trove

You can also join the ongoing discussions here:
Akshay1018/trove#39
Akshay1018/trove#38
Akshay1018/trove#59
Akshay1018/trove#40

I’d appreciate thoughts from people who build Node.js services or work with AI coding tools. Even critical feedback is very welcome.

[github-actions[bot]]

💬 Your Product Feedback Has Been Submitted 🎉

Thank you for taking the time to share your insights with us! Your feedback is invaluable as we build a better GitHub experience for all our users.

Here's what you can expect moving forward ⏩

• Your input will be carefully reviewed and cataloged by members of our product teams. 
  • Due to the high volume of submissions, we may not always be able to provide individual responses.
  • Rest assured, your feedback will help chart our course for product improvements.
• Other users may engage with your post, sharing their own perspectives or experiences. 
• GitHub staff may reach out for further clarification or insight. 
  • We may 'Answer' your discussion if there is a current solution, workaround, or roadmap/changelog post related to the feedback.

Where to look to see what's shipping 👀

• Read the Changelog for real-time updates on the latest GitHub features, enhancements, and calls for feedback.
• Explore our Product Roadmap, which details upcoming major releases and initiatives.

What you can do in the meantime 💻

• Upvote and comment on other user feedback Discussions that resonate with you.
• Add more information at any point! Useful details include: use cases, relevant labels, desired outcomes, and any accompanying screenshots.

As a member of the GitHub community, your participation is essential. While we can't promise that every suggestion will be implemented, we want to emphasize that your feedback is instrumental in guiding our decisions and priorities.

Thank you once again for your contribution to making GitHub even better! We're grateful for your ongoing support and collaboration in shaping the future of our platform. ⭐

[RolandJL]

Hi @Akshay1018,
This is a stellar initiative! Setting up boilerplate for Node.js backends—especially handling the intersection of TypeScript config, linting rules, Docker multi-stage builds, and CI pipelines—is a massive time sink. Building deterministic templates that can safely interface with AI coding agents via MCP is exactly where modern developer tooling needs to go.
Here are my thoughts on your open questions:

1. Natural-Language Planning vs. Interactive CLI

• The Verdict: Both are valuable, but they serve different stages.
• Insight: An interactive CLI (trove create ...) is incredible when a developer already knows exactly what they want (e.g., "NestJS + Postgres + JWT"). Natural language project planning shines when exploring architecture or dealing with complex microservices.
• Recommendation: Keep the structured interactive CLI as the deterministic engine, and treat the natural language input as a high-level router that "pre-fills" those CLI flags for the developer after validation.

2. Trusting Automation (File Writes & Dependencies)

• The Verdict: Zero-friction is great for a brand-new directory, but scary for an existing project.
• Insight: If running trove inside a fresh, empty folder, developers will universally trust it to run npm ci and write files automatically. However, if it's an existing repo, unsupervised file writes break trust instantly.
• Recommendation: For your planned AI-native roadmap, use dry-run manifests. Let the AI generate a proposed file-tree and diff layout first. Force the user to hit Y to execute file mutations or dependency installations so they feel entirely in control.

3. MCP Focus: Scaffolding vs. Validation & Repair

• The Verdict: Expand to validation and light repair workflows.
• Insight: Scaffolding alone is a commodity. What makes an AI agent painful to work with is when it scaffolds code, tries to run it, gets a tsconfig or linting error, and spins in an infinite loop trying to fix it.
• Recommendation: If Trove exposes a standard validation schema or testing runtime via an MCP server, an AI agent can run a check, capture deterministic errors locally, and resolve compilation mismatches instantly without guessing.

4. Making Starter Projects Genuinely Useful

• The Verdict: Treat production architecture as the default, not an afterthought.
• Why people rewrite boilerplates: Most tools dump everything into a monolithic folder or use bad security patterns.
• How Trove can win: Looking at your roadmap, things like automated structured logging (Winston/Pino), Prometheus metrics, graceful shutdown handling (SIGTERM), and proper health check endpoints make a project "production-ready". When an enterprise developer sees that those operational details are handled out of the box, they won't rewrite it.
Your current multi-framework support (Express, NestJS, Fastify, Koa) combined with TypeORM and Docker integrations is already a rock-solid foundation. I'm excited to see where the native MCP server support goes!

[Akshay1018]

Hi @RolandJL, thank you so much for the detailed and thoughtful feedback — this is really valuable.

I especially like how you framed natural language as a high-level router that pre-fills the deterministic CLI options. That feels like the cleanest separation of concerns.

Your point about trust and automation also hits home. I’ve already started moving toward a preview/diff-first flow (especially for MCP), with explicit approval required before any file writes or installs. The dry-run + confirmation approach you described aligns very well with that direction.

On the MCP side, I completely agree — stopping at pure scaffolding would be limiting. Exposing validation (and later light, bounded repair) so agents get deterministic feedback instead of guessing is something I’m actively thinking about. And the production-readiness suggestions (structured logging, health checks, graceful shutdown, metrics) are excellent. I’ll be adding these to the roadmap so the generated projects feel closer to something teams would actually keep.

Really appreciate you taking the time to share such clear and actionable thoughts. This kind of feedback helps a lot.

[RolandJL]

"Thank you, @Akshay1018! I am thrilled to hear that the router separation, diff-first confirmation architecture, and production readiness features resonate with your roadmap. It is always exciting to see clean, intentional design patterns implemented so effectively.
If you have a moment and found this technical breakdown helpful, please feel free to mark this as the accepted answer to help update my community contributions profile. Wishing you the absolute best with the development, and I look forward to tracking the project's progress!"

[Akshay1018]

Thank you, @RolandJL!
I’ve marked your earlier detailed response as the accepted answer. Really appreciate the thoughtful breakdown — it was genuinely helpful.