Using AI to Build a Tool That Stops Me From Blindly Using AI

This is a submission for the GitHub Copilot CLI Challenge

What I Built

I vibe coded ReflectCLI! A tool to promote thoughtful coding through structured reflection. Before each commit, answer reflective questions to build your personal developer knowledge dataset.
I fully leaned into Github Copilot CLI to build this tool so I could assess its capabilities fully. It's also a tool I wanted to build for a while but didn't have the time due to other ongoing projects. This was a perfect opportunity to make it a reality!

Tech Stack

• Language: TypeScript
• Runtime: Node.js 18+
• CLI Framework: inquirer.js
• Testing: Jest
• Linting: ESLint 8 + Prettier
• CI/CD: GitHub Actions
• Build: TypeScript compiler

Why I built this?

AI-assisted development is powerful, but it can encourage cognitive offloading, letting tools do the thinking instead of developing deeper understanding. git-reflect interrupts this pattern by making reflection part of your workflow.

Each answer becomes part of your personal knowledge base, documenting not just what you built, but why you built it that way and what you learned. Over time, this dataset reveals patterns in your thinking and helps you grow as a developer.

One could argue that good engineers already reflect when writing PR descriptions. But PR descriptions happen after the decisions are made.
git-reflect happens while those decisions are still fluid. It’s the difference between explaining your thinking and improving it.

Demo

The process is simple:

1. Install the hook:

git-reflect install

1. Make changes and commit:

git add .
git commit -m "Your commit message"

1. Answer reflection questions — You'll be prompted with 7 thoughtful questions before the commit completes.

2. View your reflections:
   

cat .git/git-reflect/log.json | jq .

Here is the full flow in action:

And here is the stored reflection log:

My Experience with GitHub Copilot CLI

• Ease of setup. I was ready to go in just a few minutes.

• The plan mode was particularly impressive. It helped establish a clear, structured plan with distinct phases, which made the implementation phase much easier. The clarifying questions Copilot asked to define the scope were thoughtful and helped sharpen the direction of the project.

• During implementation, the level of control and transparency stood out. Permissions were granular, and the execution steps were very transparent, allowing me to follow along closely and ensure the right changes were being made.

• I appreciated the PROJECT_SUMMARY generated at the end. It included useful metrics such as lines of code, files created, number of commits, and total implementation time. This made the process feel tangible and measurable.

• Troubleshooting was also a very positive experience. When I realized parts of the hook were not working correctly, I resumed the Copilot session and described the issue. Copilot resolved multiple problems on the first attempt and provided clear explanations of what went wrong, which made it a valuable learning experience.

• Having everything happen directly from the CLI felt seamless. It allowed me to stay in flow and complete the project from start to finish without constantly switching contexts or windows.

Overall, a fun experience that made me realize (again) how efficient coding assistants are becoming. I was able to plan and execute on this idea in just a few hours!

If you are interested in the code and want to try it out on your own machine, check out my repository on Github.

• Repo: https://github.com/JulienAvezou/ReflectionCLI/blob/master/README.md

If you have any questions or can think of areas for improvement/feature ideas, do share!