GoPlan: AI-Powered Task Management Built with GitHub Copilot CLI

This is a submission for the GitHub Copilot CLI Challenge

What I Built

GoPlan is a planning-first task management system that uses semantic intelligence to help teams make better decisions. Unlike traditional task managers, GoPlan requires justification for every task and uses AI embeddings to find similar past work, preventing duplicate effort and surfacing insights from your team's history.

Tech Stack

• 
  Backend: Go + Fiber (REST API with Swagger)


• 
  Frontend: React + TypeScript + Tailwind CSS


• 
  Database: PostgreSQL with pgvector extension


• 
  AI/ML: Python FastAPI embedding service (sentence-transformers)


• 
  Infrastructure: Docker Compose with health checks

Key Features

✨ Semantic Task Search - Find similar tasks using vector embeddings


📋 Mandatory Justifications - Every task requires a "why" before execution


🔗 Smart Task Linking - Discover dependencies, blockers, and related work


👥 Team & Project Management - Multi-tenancy with role-based access


📊 Analytics Dashboard - Insights from your planning patterns

Demo

Live Demo Links

🔗 Repository: github.com/amanasmuei/goplan


📺 Video Walkthrough: [Link to demo video]

Screenshots

Dashboard - Task Overview



View all tasks with status, assignments, and semantic similarity scores

Task Creation with AI Suggestions



As you describe a task, GoPlan finds similar past work using embeddings

Architecture Diagram

Frontend (React) → Backend API (Go) → PostgreSQL + pgvector

                         ↓

                  Embedding Service (Python)

Quick Start

# Clone and start all services

git clone https://github.com/yourusername/goplan

cd goplan

make dev



# Run API and frontend

make api      # Backend on :8080

make frontend # Frontend on :3000



# Visit http://localhost:3000

My Experience with GitHub Copilot CLI

Building GoPlan with GitHub Copilot CLI was a game-changer. Here's how it transformed my development workflow:

🎯 Architecture Planning Made Easy

Instead of jumping straight into code, I used Copilot CLI to explore and plan:

# Understanding the codebase structure

gh copilot explain "how does the vector similarity search work in task_repository.go"



# Planning new features

gh copilot suggest "add a background worker to process tasks without embeddings"

The CLI helped me understand complex interactions between the Go backend, PostgreSQL vector operations, and the Python embedding service without context switching.

⚡ Rapid Development with Context Awareness

Before Copilot CLI: I'd search docs, copy-paste examples, and spend hours debugging integration issues.

With Copilot CLI: It understood my entire stack and suggested contextually relevant solutions:

• Suggested proper pgvector query syntax with the <-> distance operator


• Generated Swagger annotations that matched my existing handler patterns


• Created React Query hooks that aligned with my Zustand store architecture


• Wrote Docker health checks for the embedding service

🧪 Test Generation & Debugging

One of my favorite uses:

gh copilot suggest "write a test for TaskService.CreateTask that mocks the embedding service"

It generated tests using testify/mock (which I was already using) and even included edge cases I hadn't considered.

📚 Documentation & Best Practices

Creating the .github/copilot-instructions.md file with the CLI's help meant:

• Future sessions understood my architecture patterns instantly


• New team members could ask Copilot about conventions


• The instructions stayed up-to-date with actual code

💡 Key Moments Where Copilot CLI Saved Me

1. 
   Vector Embedding Integration: Suggested the exact pgvector-go types and distance operators needed for semantic search


2. 
   Middleware Patterns: Generated JWT auth middleware that worked seamlessly with Fiber's context


3. 
   Database Migrations: Helped structure incremental migrations with proper enum types and constraints


4. 
   E2E Test Setup: Configured Playwright with the right base URLs and browser matrix for CI/CD

📈 Productivity Impact

• 
  ~40% faster development - Less time searching docs, more time building


• 
  Fewer bugs - Context-aware suggestions meant better patterns from the start


• 
  Better architecture - CLI helped me think through design before implementing


• 
  Cleaner code - Suggestions followed my existing patterns consistently

🚀 What Makes This Submission Special

This isn't just a CRUD app—GoPlan tackles a real problem: organizations lose institutional knowledge and repeat work because past decisions aren't discoverable. By combining:

• 
  Planning-first philosophy (justify before you build)


• 
  AI-powered similarity search (find relevant past work)


• 
  GitHub Copilot CLI (build faster with better context)

...I built a system that helps teams learn from their history.

🎓 What I Learned

The GitHub Copilot CLI isn't just about autocomplete—it's about having an intelligent development partner that:

• Understands your entire codebase context


• Suggests solutions that match your existing patterns


• Helps you learn new technologies (I hadn't used pgvector before!)


• Makes documentation actually useful

Try It Yourself

git clone https://github.com/amanasmuei/goplan

cd goplan

make docker-up  # Starts all services

Visit http://localhost:3000 and create your first task. Watch as GoPlan finds similar work from your team's history!

Built with ❤️ using GitHub Copilot CLI