GitHub Copilot CLI Challenge: I Built an AI Mentor in My Terminal

#devchallenge #githubchallenge #cli #githubcopilot

GitHub Copilot CLI Challenge Submission

**This is a submission for the GitHub Copilot CLI Challenge

What I Built

I didn't build clioraOps because I wanted another CLI tool.

I built it because I was tired of pretending I fully understood what I was running in my terminal.

A year ago, when I started my cloud/DevOps journey, I noticed a pattern in how I was learning. I would search for a command, copy it, run it, and move on once it worked. The problem was that execution became faster, but understanding didn't always follow.

If something broke later, I had to start over.

And in DevOps, that's dangerous.

Infrastructure mistakes aren't always obvious. A single command can delete data, expose services, or break prodution systems. I realized that many learners including myself, were optimizing for speed instead of comprehension.

So I built clioraOps

clioraOps is an AI-powered DevOps learning companion that lives inside the terminal. Instead of just giving answers, it focuses on helping developers understand what they are doing before they execute it.

The goal isn't automation

The goal is confidence through understanding.

clioraOps helps users:

Understand deeply through contextual explanations
Learn safely by reviewing commands before execution
Visualize system architectures directly in the terminal
Generate production-ready configurations using best practices
Debug errors with guided reasoning instead of guesswork

Demo

GitHub Repository: https://www.github.com/CloudFay/clioraOps

Example Interactions

Asking conceptual questions in natural language
Safely testing risky commands before execution
Generating production-ready Docker or CI/CD configurations
Visualizing architectures like microservices or pipelines
Debugging infrastructure errors step-by-step

The experience is conversational but structured around learning rather than shortcuts.

My Experience with GitHub Copilot CLI

GitHub Copilot CLI played a major role in how this project evolved.

Initially, I approached it as a productivity tool — something that could help generate commands faster. But during development, it became more than that. It became a thinking partner inside the terminal.

The biggest challenge wasn’t writing code. It was understanding how to structure interactions between Python workflows and an AI-driven CLI environment.

Some challenges I faced included:

Version and command format changes during development
Handling subprocess interactions cleanly
Designing prompts that encouraged explanation instead of shortcuts
Debugging environment and installation issues across systems
Balancing flexibility with safety in command execution

There were moments where things broke repeatedly especially around CLI integrations and environment setup but those moments forced me to understand the tooling at a deeper level.

The biggest realization was this:

Copilot CLI is most powerful when used as a collaborator, not just an autocomplete tool.

It helped accelerate experimentation while still allowing me to stay in control of architecture and decision-making.

For someone building DevOps tools, that balance matters.

Challenges Faced

Building ClioraOps came with several practical challenges:

Designing an MVP without overcomplicating the architecture
Ensuring safety checks didn’t slow down interaction
Making AI explanations useful for both beginners and advanced users
Supporting both cloud AI (Gemini) and local models (Ollama)
Structuring the project so it remains extensible as features grow

One of the hardest parts was resisting the urge to add more features early. Keeping the MVP focused on learning, safety, and clarity made the tool stronger.

What This Project Means to Me

ClioraOps represents my transition from simply learning tools to building tools that help others learn better.

DevOps can feel overwhelming at the beginning. There are too many tools, too many commands, and too many ways to break things.

I wanted to build something that reduces fear without removing responsibility.

Something that teaches before it executes.

And something that grows with the developer using it.

Final Thoughts

AI is changing how we build software.

But understanding still matters.

clioraOps is my attempt to make sure speed doesn’t replace learning, especially in infrastructure and DevOps, where understanding is the difference between automation and reliability.

If you’re learning DevOps or building in the terminal every day, I’d love your feedback.