GitEase — Git in Plain English

Simukuka Akakandelwa — Fri, 06 Feb 2026 12:48:02 +0000

This is a submission for the GitHub Copilot CLI Challenge.

What I Built
Have you ever known exactly what you wanted to do in Git…

but the moment you open a terminal, the commands feel like a foreign language?
If you’ve used Git long enough, you’ve probably been here:
You know what you want to do —

but you don’t know the right command, or worse, you’re not sure which one is safe.
So you Google something like:

“undo my last commit but keep my changes”
You see:

git reset --soft

--mixed

--hard

Someone mentions force push.
And suddenly, you hesitate.
Git is powerful — but that power comes with sharp edges, especially when you’re moving fast or still learning.

The Real Problem Isn’t Git — It’s Translation

What always bothered me wasn’t that Git was hard.

It was that I had to translate my intent into exact, unforgiving syntax.
I knew what I wanted:

Undo something
See what changed
Reset safely
Fix a mistake without breaking everything

But Git doesn’t understand intent — it understands commands.
That gap between what I mean and what I have to type is where mistakes happen.
So I asked a simple question:

What if I could just tell Git what I want to do — in plain English?

Introducing GitEase

That question became GitEase.

GitEase is a CLI that lets you describe Git actions in natural language and translates that intent into real Git commands using GitHub Copilot CLI — with safety, transparency, and user control built in.

GitEase is intentionally not full automation.

It doesn’t hide Git.

It doesn’t silently run commands.

Instead, it:

Interprets intent
Builds an explicit plan
Explains what will happen
Warns when something is risky
Executes only with confirmation

GitEase treats Git like a powerful tool that deserves respect.

How GitEase Works in Practice

GitEase understands both simple actions and full Git workflows — because real Git usage is rarely just one command.

🧠 From intent to execution

gitease "undo my last commit but keep my changes"

GitEase translates this intent into:
git reset --soft HEAD~1

Before running it, GitEase:
• Explains what the command does
• Classifies the risk level
• Asks for confirmation

🔁 Intent-aware Git workflows

GitEase also understands compound intent — the kind developers use every day:
gitease "stage everything, commit, and push"
Instead of collapsing this into a single opaque action, GitEase produces a clear execution plan:
Workflow Plan (4 steps):

1. git status
   Check repository state

2. git add .
   Stage all changes

3. git commit -m "Your commit message"
   Create a commit

4. git push
   Push to the remote repository

Each step is explicit.
Each step is explained.
Each step can be approved or aborted.

This turns vague intent into auditable Git behavior.

⚠️Safety Is a First-Class Concept

Some Git commands are inherently dangerous.
GitEase treats them that way.
If an action could:

Discard changes
Rewrite history
Push destructive updates

GitEase stops and warns you:
⚠️ Warning: This operation may permanently discard changes.
You always see:

What will run
Why it’s risky
What the consequences are

And the default answer is No.

What Makes GitEase Different

GitEase isn’t trying to replace Git expertise — it’s designed to build confidence.

🤖 AI-Powered Translation: Uses GitHub Copilot CLI to convert intent into real commands
🧠 Workflow Awareness: Understands multi-step Git operations, not just one-liners
🛡️ Safety-First Execution: Warnings and confirmations for destructive actions
📊 Context-Aware: Shows status, diffs, and logs when they matter
⏮️ Undo History: Tracks executed actions so mistakes are reversible
📚 Educational by Design: You learn Git while using it

DEMO

Try it yourself:
• 📦 npm: https
• 💻 GitHub

My Experience with GitHub Copilot CLI

GitHub Copilot CLI was essential to making GitEase possible — not as a shortcut, but as the intent translation layer at the core of the tool.

Copilot is very good at generating Git commands.
What it doesn’t do is decide when those commands are safe to run.

GitEase sits in that gap.

Copilot translates intent.
GitEase adds:
• Structure
• Guardrails
• Judgment

This project taught me that AI works best when paired with constraints, not autonomy.
What I Learned

Building GitEase reinforced a few important lessons:
• Simpler tools can still be deeply powerful
• Safety and clarity matter as much as speed
• AI should assist judgment, not replace it
• Developer experience is a deliberate design choice

GitEase won’t replace Git expertise — but it helps people gain confidence while learning it.

⸻

Closing Thoughts

Git is one of the most important tools developers use every day — but it doesn’t have to feel intimidating.

GitEase bridges the gap between what developers want to do and what Git expects them to type — with Copilot CLI as the translator and GitEase as the safety layer.

Forem: Simukuka Akakandelwa