AI is making me realize, I don’t just need skills–I need vision.

Which is why I’m back to developing software on Linux 🤣. I know what I miss from other operating systems, and I can use AI to recreate it. I wound up getting a Github Copilot Plan. The Premium Requests reset every month. Since we’re near end of the month let’s see what “I” can make.

Modified from Nedroid Comics.

I’ve been hearing about Playwright and this “MCP” thing. I thought, what if AI develops apps with an MCP server built in. Then it can test and leverage the app using MCP.

My goal with AI is to fill in missing gaps. I wanted native Linux GUI applications to replace the tools I miss. (By the way, if you’re on Linux and miss Ulysses, try my Markdown Editor ThiefMD).

The Plan

1. Implement functionality like applications I use that prevent me from switching to Linux.
2. AI does all the heavy lifting.
3. Rust for SEO. Just kidding. Rust for memory safety and its helpful compiler. If AI can compile it, the problem becomes verifying functionality.

It’s mostly a Ralph Loop. AI+Rust+MCP is kind of like Playwright-MCP for this app. 🤔 GTK has an Inspector/Debugger, so I do wonder if a general purpose MCP could be developed for GTK developers. That’ll be an experiment for another day.

GifThatForYou

GifThatForYou is a screen recorder that generate a GIF. I loved peek. GifThatForYou is nowhere close. It does allow to choose a Window or Screen to record.

😅 One issue with the MCP server: Portal Permissions. The user has to approve every screen recording.

Could you imagine it though? If AI could record GIF’s of the development progress?

UltimateSlice

Final Cut on Mac. Ultimate Slice on Linux. I am hilarious.

This is where Rust+AI really shined for me. AI excels at Rust.

UltimateSlice is my second attempt at an NLE experiment. My first attempt was in Vala. All I got was a glitchy mess.

Ultimate Slice is an “easy to use” non-linear video editor.

Admittedly, NLE’s are nothing new. GStreamer and FFmpeg are doing all the heavy lifting. But Copilot and I did some work (mainly Copilot).¹

Development kind of followed the Ralph Loop. Copilot maintained a roadmap, changelog, and documentation.

## Required Documentation Updates (Agent Rule)  

When making changes, update these files as part of the same work:  

1. `CHANGELOG.md` — append a concise entry under **Unreleased** describing what changed and why.  
2. `ROADMAP.md` — keep implemented/planned checklists accurate for any affected feature area.  
3. **`docs/user/`** — update (or create) the relevant feature markdown file(s) in `docs/user/`:  
  - Each feature has its own file (e.g. `timeline.md`, `inspector.md`, `export.md`).  
  - Add or update keyboard shortcuts in both the feature file **and** `docs/user/shortcuts.md`.  
  - Keep `docs/user/README.md` table of contents accurate.  
4. MCP coverage — when adding a new user-facing feature, also add/update an MCP tool for it if one does not already exist and the feature is automatable via MCP. Test each feature using the MCP server.  
5. Dependency/license coverage — when adding a new crate to `Cargo.toml`:  
  - Verify the crate license is compatible with the project.  
  - Add/update the crate listing in the in-app **About & Open-source credits** view.  
  - Add/update the crate listing in `README.md`.  

Do this continuously as work is completed (not only at the end of large efforts).  

While I was away from my PC, Copilot would pick what to build.

I’d come in and test end-user functionality. I’d provide feedback and ask Copilot to add to the roadmap.

Prompting for Improvement

On my old XPS Laptop, I could get single video track editing working. This was with 5.3K and 6.2K video sources (rendered into proxies).

In software development, two major lessons I’ve learned are:

1. Always be willing to ask questions.
2. Seek advice from an expert.

Copilot will do what you ask. Copilot will answer the questions you ask. Here is is it investigating a crash.

Me saying “make it faster” didn’t really do much. Asking for techniques to make an NLE run smoother gave back:

• Proxy media
• Background threads
• Compositing
• Hardware Acceleration
• and more.

Asking it to Profile and Test the application was like watching a “Let’s Play” video. Copilot would edit the same video over and over. Analyzing the logs, it would iterate and test again.

Copilot summarized its techniques and findings.

Asking Copilot to generate these summaries, and feeding the summary to a new instance helps get fresh perspectives.

Asking Claude for design from the summaries also helped. I kept hitting the limits of the Pro Plan, so Claude acted as a consultant.

My Thoughts on AI

These experiments were a lot of fun. They combined 2 things I really love:

1. Let’s Play videos
2. Backseat Driving

There’s still a lot on the roadmap.

One of the downsides of being a human software developer is ramping up. Learning API’s, adapting for shifts in trends–it takes time.

With AI, I take more on a Program Manager role. I take customer feedback, form it into action, and give it to Copilot.

Copilot is really cool though.

If I think it, I can make it.