DEV Community: Mohamed Ali

From Educational Shell to AI-Powered Terminal: Finishing My C++ Project with Local LLMs

Mohamed Ali — Sun, 07 Jun 2026 19:30:31 +0000

This is a submission for the GitHub Finish-Up-A-Thon Challenge

What I Built

I built MyShell, a customizable command-line shell written in C++ for Windows that combines a Linux-style command experience with local AI-powered command translation.

This project started as a purely educational project. My goal was to understand how terminals and operating systems work behind the scenes by building a shell from scratch. Instead of only learning the theory, I wanted to explore command parsing, process creation, file system operations, and terminal interfaces by implementing them myself.

The shell originally provided basic commands such as directory navigation, file operations, and external command execution. It was a great way to learn how a terminal communicates with the operating system and how command interpreters are structured internally.

When I discovered the GitHub Finish-Up-A-Thon Challenge, I saw it as the perfect opportunity to revisit the project and push it much further than its original educational scope. Rather than leaving it as a learning experiment, I decided to transform it into a more complete and modern terminal experience by adding AI-powered features, safer command execution, and a cleaner architecture.

Today, MyShell supports built-in commands, external program execution, command chaining, file management, and natural language interaction powered by a local LLM.

One of the main goals of the project is to make command-line interfaces more approachable. Instead of memorizing commands, users can simply describe what they want to do and let the shell translate their request into executable commands.

Screenshot

Repository

GitHub Repository:

https://github.com/MohamedAli1937/Cpp-Shell

Features Demonstrated

Linux-style commands on Windows (ls, pwd, mkdir, touch, rm)
External program execution
Command chaining with &&
AI-powered natural language command translation
Safety previews and confirmation prompts for potentially dangerous operations
Local LLM integration through llama.cpp

Example

ai create folder src and a file main.cpp inside

Translated into:

mkdir src && cd src && touch main.cpp

The shell then analyzes the generated command, checks its risk level, shows a preview when necessary, and executes it after user confirmation.

Since the AI runs locally through llama.cpp, no cloud API is required and users can choose whichever GGUF model they prefer.

The Comeback Story

When I started this challenge, MyShell was already working but felt unfinished.

The original version included:

Basic command parsing
Directory navigation
File and folder operations
External command execution
Colored terminal output

It successfully achieved its educational purpose, but there were many ideas that I had never implemented.

The Finish-Up-A-Thon gave me the motivation to finally return to the project and build the features I had been postponing.

What I Added

🤖 AI Command Translation

The biggest addition was a local AI system that allows users to interact with the shell using natural language.

Instead of typing commands manually, users can now write:

ai show me all files

and the shell automatically translates it into:

ls

More complex requests can also be converted into multiple commands:

ai create folder src and a file main.cpp inside

↓

mkdir src && cd src && touch main.cpp

🛡️ Safety Layer

AI-generated commands can be powerful, but they can also be dangerous.

To make the feature safer, I implemented:

Command planning
Risk classification
Dangerous operation detection
Confirmation prompts before execution

This prevents accidental destructive operations while keeping the workflow simple.

🔗 Command Chaining

I added support for chained commands using &&, making it possible to execute complete workflows in a single instruction.

📁 Improved File Operations

The shell gained:

touch command support
Multiple file creation
Multiple folder creation
Recursive deletion support
Better command handling

🏗️ Better Architecture

To support future growth, I reorganized the project into dedicated AI modules:

AIManager
LLMInterface
CommandPlanner
SafetyChecker
Preview

This separation made the codebase cleaner and easier to maintain.

The project now feels much closer to the vision I originally had: a customizable shell that combines traditional command-line workflows with modern AI assistance.

My Experience with GitHub Copilot

GitHub Copilot played a significant role during the AI upgrade phase of this project.

One area where it helped a lot was building the communication layer between MyShell and the local llama.cpp server. Working with WinHTTP in C++ can be verbose, and Copilot frequently suggested the boilerplate required for HTTP requests, response handling, and error checking, which saved a considerable amount of time.

It was also useful when creating the new AI architecture. While designing classes such as AIManager, LLMInterface, CommandPlanner, and SafetyChecker, Copilot often completed repetitive class definitions, constructors, and method implementations, allowing me to focus more on the overall design of the system.

Another place where it helped was command-processing logic. When implementing command chaining, argument parsing, and safety checks, Copilot suggested code patterns that sped up development and helped reduce repetitive typing.

I still made all architectural decisions myself, but Copilot acted like a pair programmer that handled much of the boilerplate while I focused on the behavior and user experience of the shell.

For a project that combines systems programming, command parsing, and AI integration, that productivity boost was incredibly valuable.

What's Next?

MyShell is still evolving. Some features I would like to add next include:

Command piping (|)
I/O redirection (>, <)
Background process execution
Smarter context-aware AI command generation
Additional built-in commands
Cross-platform support
Better support for local AI models

This challenge helped me transform MyShell from a simple educational experiment into a much more complete project. More importantly, it gave me a reason to finally finish features that had been sitting in my backlog for months.

Thanks to GitHub and DEV for organizing the Finish-Up-A-Thon and motivating developers to bring unfinished projects back to life.

🚀 GitFlow Dashboard: From Paused Side Project to v1.0.0

Mohamed Ali — Thu, 04 Jun 2026 11:32:25 +0000

This is a submission for the GitHub Finish-Up-A-Thon Challenge

What I Built

GitFlow Dashboard is a desktop application built with Electron, React, and TypeScript that helps developers visualize and manage their GitHub workflow in one place.

The idea started while I was contributing to open source projects and preparing GSoC applications. I found myself constantly switching between GitHub, Git, project boards, issues, pull requests, and local development tools.

To solve that problem, I started building GitFlow Dashboard: a unified workspace for managing the entire development pipeline.

The project began as a basic prototype with GitHub integration and a Kanban board. While the foundation was there, it was far from complete and lacked many of the features needed for a polished user experience.

The GitHub Finish-Up-A-Thon gave me the motivation to return to the project and finally turn it into something I could confidently release.

🎥 Demo

https://github.com/user-attachments/assets/e8f63577-7135-44d3-997e-246d6450c31c

Repository

https://github.com/MohamedAli1937/GitFlow-Dashboard

Download : Windows Installer (v1.0.0)

👉 GitFlow.Dashboard-Windows-1.0.0-Setup.exe

✨ Features

GitHub authentication
Login and signup flow
Multi-account support
Kanban board workflow management
Repository integration
Pull request tracking
Issue tracking
Branch visualization
Branch management view
GitHub account statistics
Quick "View on GitHub" actions
Integrated help guide
Improved UI/UX design
Desktop application packaging
Release management

📸 Screenshots

Login Page

Repository Dashboard

Contributions Dashboard

🔥 Before vs After

Before

The project existed before the challenge but was still an unfinished prototype.

What existed:

Basic GitHub integration
Early Kanban board
White theme UI
Limited workflow visibility
No authentication
No account management
No releases

After (Finish-Up-A-Thon Version)

What was added:

Modern dark theme redesign
Login & signup system
Multi-account support
Branch management
GitHub account statistics
Built-in help guide
Improved documentation
Production-ready packaging
Release v0.1.0
Release v1.0.0

🔄 The Comeback Story

GitFlow Dashboard started before the GitHub Finish-Up-A-Thon challenge.

I began building GitFlow Dashboard in early May 2026 and implemented the first core features, including GitHub integration and a Kanban board. However, university exams arrived, and I had to put the project on hold before it reached the level I originally envisioned.

When I discovered the GitHub Finish-Up-A-Thon challenge, I saw it as the perfect opportunity to return to the project and finally finish what I had started.

During the challenge, I redesigned the interface, added authentication, implemented multi-account support, introduced branch management features, added account statistics, created a help guide, improved documentation, prepared releases, and shipped the first stable version: v1.0.0.

What began as a paused side project became a complete desktop application that developers can actually use to manage their GitHub workflow.

🛠 Major Improvements

Authentication & Account Management

Added login and signup functionality
Added support for multiple GitHub accounts

User Experience

Redesigned the interface
Improved navigation and usability
Added a built-in help guide

GitHub Workflow Features

Added branch viewing and management
Added account statistics
Added quick links to open repositories directly on GitHub

Project Quality

Improved documentation
Expanded the README
Added demo content
Prepared production builds

Releases

Published a test release (v0.1.0)
Published the first stable release (v1.0.0)

🤖 My Experience with GitHub Copilot

GitHub Copilot played an important role throughout the finishing process.

I used Copilot to:

Accelerate UI development
Generate boilerplate code
Refactor components
Improve TypeScript typings
Debug implementation issues
Draft documentation and README improvements
Explore alternative implementation approaches

Rather than replacing development work, Copilot acted as a productivity partner that helped me move faster and spend more time refining the overall experience.

🚀 What's Next?

Although GitFlow Dashboard has now reached its first stable release, I plan to continue improving it with:

GitHub Actions integration
Enhanced analytics
Notifications and activity tracking
Additional workflow automation features

This challenge helped me finally finish a project that had been sitting unfinished during my university exam period and transform it into a real release that developers can use.

Thanks for reading!