DEV Community

Dhanush Shetty
Dhanush Shetty

Posted on

Blueprint — Universal Project Scaffolding That Actually Scales

#devchallenge #githubchallenge #cli #githubcopilot

GitHub Copilot CLI Challenge Submission

This is a submission for the GitHub Copilot CLI Challenge

🚀 Project Overview

Blueprint is a universal project scaffolding CLI tool written in Go. It’s designed to eliminate the "copy-paste tax" when starting new projects. Unlike rigid scaffolding tools, Blueprint uses an intelligent template system with interactive prompts, recursive feature composition, and dependency management.

Whether you're starting a Go API, a Python FastAPI service, or a CLI tool, Blueprint handles the boilerplate so you can focus on building.

📦 Installation

Download the latest binary for your platform from the Releases page.

👉 Explore the source code

🎬 Demo

Blueprint Demo

🤖 How I used GitHub Copilot CLI

Before starting this project, I was deeply skeptical about AI tools. I’ve always preferred writing every single line of code by hand, viewing anything else as a shortcut that compromises quality. However, building Blueprint taught me that when used correctly—as a high-level architectural partner rather than a blind code generator—these tools are incredibly powerful. I’ve put my heart and soul into this project, and I learned how to leverage the agentic workflow to maintain high standards and avoid the "AI slop" that often plagues automated development.

GitHub Copilot CLI acted as an interactive, agentic TUI... I specifically leveraged plan mode powered by the claude 4.6 opus model to orchestrate the development. Here’s how it helped:

  1. Iterative Architecture Design in Plan Mode: Before writing code, I used Copilot CLI's plan mode to map out the project's structure. We had a back-and-forth conversation about the "Resolver Chain" pattern, where the model proposed a step-by-step implementation plan to ensure local templates could gracefully override built-in ones.
  2. Solving Complex Logic with Claude 4.6 Opus: The core of Blueprint involves a recursive template composition engine with circular dependency detection. I used the reasoning capabilities of the claude 4.6 opus model to implement the "path tracking" algorithm, catching potential off-by-one errors in my slice manipulations during the planning phase.
  3. Integrating Modern UI: I used the charmbracelet/huh library for interactive prompts. Copilot CLI helped me navigate the library's API and generated the code for dynamic forms that adjust based on template variables, significantly speeding up the TUI development.
  4. Context-Aware Development: I utilized a .github/copilot-instructions.md file to provide project-specific context. This allowed Copilot CLI to act as a true expert on the Blueprint codebase, ensuring that every new feature or refactor adhered to our established conventions.
  5. Test-Driven Development: Copilot assisted in generating comprehensive, table-driven tests for the template renderer and composer. It didn't just write the tests; it helped me reason through the edge cases like nested includes and variable scoping.
  6. Comprehensive Documentation: I used Copilot CLI to draft the architectural overview and template specifications. By providing the source code as context, it generated clear, concise, and professional-grade documentation that accurately reflects the internal workings of the project. Honestly, writing all of this by hand would have been a very painful chore, but the result is a project that is very well documented from day one.

📚 Documentation

The project is extensively documented to ensure ease of use for both template authors and contributors:

Note to Judges: I highly recommend reading the documentation linked above, as I've chosen not to pollute this post with the app's internal technical details.

🐹 Why Go? Idiomatic Design & Philosophy

Blueprint was built with Go not just for its performance, but for its philosophy. I’ve aimed to adhere strictly to idiomatic Go principles: explicit error handling, minimal abstractions, and "zero magic." By avoiding heavy frameworks and keeping dependencies light, the codebase remains readable and maintainable.

My goal was to design Blueprint in a way that would please seasoned Go developers—where the data flow is obvious, the interfaces are small and purposeful, and the system behaves predictably. It's a "Go-first" tool that honors the language's commitment to simplicity and clarity.

🛠️ Tech Stack

✨ Key Features

  • Universal Templates: Scaffold projects in any language using a single YAML-based format.
  • Interactive Prompts: A guided setup experience that asks only for what it needs.
  • Feature Composition: Want to add testing or logging to your basic template? Just use the --include flag to compose features together.
  • Dry Run & Overwrite Protection: Preview what will be generated before a single byte is written to disk.
  • Non-Interactive Mode: Perfect for CI/CD and automation using --yes and --var flags.

🧩 Challenges & Learnings

The biggest challenge was building a composable template engine. Traditional tools usually have a flat structure. Blueprint allows a "Go API" template to include a "Testing" feature, which itself might include a "CI" component.

Implementing the recursive merging of files, dependencies, and variables while ensuring that the "earliest definition wins" (to allow project-level overrides) required careful state management. Copilot CLI was a huge help in brainstorming the mergeTemplate logic and ensuring the slice operations were idiomatic and bug-free.

I also learned the importance of the "No silent side effects" principle. Blueprint deliberately avoids automatically running post-init commands (like go mod tidy) or overwriting files unless explicitly forced. This build-up of trust with the user is critical for a tool that modifies their local filesystem.

Finally, I made the conscious decision to avoid heavy configuration frameworks like Viper. Instead, I implemented a custom hierarchical loader to stick to Go's "zero magic" philosophy. This ensures that the configuration logic is explicit, easy to debug, and doesn't introduce hidden behaviors—a standard I maintained across the entire codebase.

⚠️ The "Agentic" Reality: What NOT to Expect

Through this project, I learned that while agentic tools like Copilot CLI are transformative, they aren't "magic wands." Here’s what you shouldn't expect them to do:

  • Drive the Vision: While Plan Mode is incredible for mapping out steps, it shouldn't be expected to own the architectural vision. You still need to be the "Lead Architect"—the AI can help implement a Resolver Chain, but you have to decide why it’s the right pattern for your users.
  • Perfect Edge-Case Detection: For high-stakes logic like Blueprint's recursive template merging and circular dependency detection, you shouldn't expect the AI to catch 100% of edge cases autonomously. It gets you 90% there, but the final 10% still requires deep human code review.
  • Inherent Design Philosophy: AI tools focus on "making it work." They won't inherently prioritize safety principles like "No silent side effects" or user trust unless you explicitly set those boundaries. You still own the product’s soul and the ethics of how it interacts with a user’s system.

🔮 Future Plans

Blueprint is just getting started! Planned features include:

  • blueprint add (The Standout Feature): This is the most ambitious part of the roadmap. While init handles the "Day 0" setup, add will handle "Day 1 and beyond." It will allow you to inject features (like Auth, Docker, or CI/CD) into existing projects. The challenge here is to evolve your codebase without breaking it.
  • blueprint search: Search for community-contributed templates directly from the CLI.
  • Remote Templates: Scaffold directly from a GitHub URL or a centralized registry.

Top comments (0)