Build a Command Center with GitHub Copilot CLI in One Day

TL;DR

• GitHub engineer built a personal productivity dashboard in one day using Copilot CLI and agent workflows
• She used a "plan-then-implement" approach: Copilot interviews her to create a spec, then builds from it
• The tech stack (Electron, React, Vite) didn't matter — she'd never built an Electron app before
• Open source repo available with full setup instructions for Microsoft 365 integration

The Big Picture

Context switching kills productivity. You're in Slack, then email, then your calendar, then back to Slack. Each app has its own interface, its own mental model, its own way of demanding your attention.

Brittany Ellich, a staff engineer on GitHub's billing team, got tired of it. So she built a unified command center that pulls everything into one interface. The interesting part isn't what she built — it's how fast she built it, and how little she needed to know about the underlying tech stack.

One day. That's how long it took to go from idea to working v1, built alongside her regular work. She'd never touched Electron before. Didn't matter. GitHub Copilot CLI and agent workflows handled the implementation while she focused on what the tool should actually do.

This isn't a story about a genius engineer building something impossible. It's about a new development pattern that's emerging: you describe what you want, AI builds it, you refine it. The technical knowledge you need has shifted from "how to implement X" to "how to specify X clearly."

How It Works

Brittany's workflow splits into two phases: planning and implementation. Both use AI, but differently.

During planning, she has Copilot interview her. Not the other way around. The AI asks questions about requirements, edge cases, user flows. This continues until they have a spec detailed enough that implementation becomes straightforward. Less guesswork means fewer rewrites.

For implementation, she runs parallel workflows. In VS Code, she keeps up to two agent sessions running simultaneously for work that needs oversight. These handle the core features, the stuff that requires decision-making.

Then there's Copilot Cloud Agent for asynchronous work. Bug fixes, tech debt, anything well-scoped that doesn't need constant supervision. She queues these up and lets them run while she focuses on the synchronous work. It's like having junior developers who never sleep and don't need code review for straightforward tasks.

The command center itself is an Electron app — cross-platform desktop framework that wraps web technologies. React handles the UI components. Vite provides the build tooling with hot reload. Tailwind for styling. WorkIQ MCP server connects to Microsoft 365 data for calendar sync.

Here's what matters: Brittany didn't need to be an expert in any of these. Agent Mode in VS Code built most of the initial implementation. When she went back to clean up the repo for public release, she could read and modify Electron code despite minimal familiarity with the framework. The AI had generated readable, maintainable code.

One caveat she noted: agents love adding code but hate removing it. When she simplified the repo, that required more hands-on work. AI is still better at creation than refactoring for simplicity.

What This Changes For Developers

The tech stack doesn't matter anymore. Not in the way it used to.

Brittany wanted to build an Electron app. She built one. She didn't spend weeks learning Electron first. She didn't read documentation cover-to-cover. She specified what she wanted and let the AI handle the implementation details. Afterward, she understood the codebase well enough to refactor it significantly.

This inverts the traditional learning curve. You used to learn a framework, then build with it. Now you can build with it, then learn it through reading and modifying the generated code. Learning happens through doing, not before doing.

The parallel workflow approach is worth stealing. Two synchronous agent sessions for high-touch work. Multiple asynchronous tasks queued with Cloud Agent for well-defined problems. This isn't just faster — it changes what you can tackle in a day. Projects that would have taken a week now fit into spare hours between meetings.

But there's a skill shift happening. The bottleneck isn't coding speed anymore. It's specification clarity. How well can you describe what you want? How effectively can you evaluate whether the generated code does what you intended? These are the new core competencies.

Brittany's "plan-then-implement" workflow addresses this directly. The interview phase forces you to think through requirements before any code gets written. It's pair programming where the AI asks the questions instead of answering them.

Try It Yourself

Brittany's repo is public. You can clone it and run it locally if you want her exact setup:

git clone https://github.com/brittanyellich/command-center-lite
cd command-center-lite
npm install
npm run dev

You'll need Node.js v18+, GitHub Copilot CLI, a Microsoft 365 account for calendar sync, and an ElevenLabs account if you want the voice assistant features. Full setup instructions are in the README.

But the more interesting experiment is building your own version. Pick a different problem. Different integrations. Different UI. Use Brittany's approach: let Copilot interview you about requirements, then implement from that spec.

The tools she used are all open source and well-supported by GitHub Copilot. Electron for desktop apps. React for UI. Vite for builds. Tailwind for styling. WorkIQ MCP for Microsoft 365 data. But you could swap any of these for alternatives and the workflow stays the same.

The Bottom Line

Use this approach if you're tired of waiting to learn a framework before building with it. If you have a clear problem to solve but don't want to spend weeks on implementation details. If you're comfortable evaluating and refining generated code rather than writing every line yourself.

Skip it if you need deep framework expertise for performance optimization or complex architectural decisions. If your project requires custom solutions that don't fit standard patterns. If you're building something where understanding every implementation detail is critical for security or compliance.

The real shift here isn't speed — though building a working app in one day is notable. It's the removal of technical barriers to solving your own problems. You don't need to be a polyglot developer anymore. You need to be good at specifying problems and evaluating solutions. That's a lower barrier to entry, but a different skill set than traditional development.

Source: GitHub Blog