TL;DR:

Here’s the repo with instruction:

https://github.com/vnt87/textpod-toc

I’ve worked with developers my entire life but I’ve never really learned how to code. Even though I have a pretty good understanding how things work from a technical perspective, even to the point where I make certain modifications to the codebase of any app to make it work in certain ways I wanted it to, I’ve never had the inclination to learn how to make things from scratch.

I’m a visual thinker, not a logical one.

Or maybe I’m just dumb but I’ve always had trouble remembering logic and syntaxes. Heck I’ve been working with git for the good part of a decade now and I still have to look up command syntaxes every damn time. I can’t remember what all the terms are, what’s with all the push, pull, fork, merge, commit, branches and all that crap. Why can’t it be as simple as upload and download. Yes maybe I’m just an idiot.

That’s why AI assistants had been a godsend for me. Now I can no longer need to remember exactly what to type into the terminal anymore. I’ve first experienced AI-assisted terminal, not in an actual terminal, but in Cursor. The first time I used it I’ve had my mind properly blown.

For example, instead of having to remember this:

git add .
git commit -m "This is a commit message"
git push -u origin main

I can simply type

upload to github with message "This is a commit message"

and the AI would give you the exact command with the exact syntax to put into your terminal, no need to remember if you’re pushing or pulling or forking or merging.

It’s like having your own personal junior dev that you can boss around. It’s fantastic!

I’ve always been a somewhat heavy CLI user before. But these new AI addition just completely launched me into the super power user category. It’s like I’ve been using an alpha MVP for the last few decades and now finally the final release is here. I can now write entire shell scripts and make the terminal do anything I want without having to know shell scripting at all.

But that’s just AI-assisted CLI. Now onto AI-assisted coding.

Back when Microsoft Github launched Copilot, everybody was losing their minds over it, but my reaction was mild at best, because I thought it only benefits the developers, I wasn’t a developer.

But with the recent influx of AI-powered tools, I can’t help but dipping my toe into that world. After having my mind blown by Cursor, I discovered Windsurf, which is even more impressive. After that I discovered non-proprietary tools like Cline and Aider that have very comparable agentic capabilities despite being opensource. And then, going full circle, it takes me back to Copilot inside VSCode.

After all, Cursor and Windsurf are just VSCode forks, who knows how long they will last. VC money maybe pouring strong now but after the low hanging fruits are gone, if they still couldn’t figure out a good business model, they won’t be here to stay. Windsurf already had some drama surrounding their recent price hike already. Sticking with the OG VSCode still sounds like a good long term strategy for me.

Another reason that led me to giving Copilot a shot is the Edit mode (which works similar to Composer in Cursor or Cascade in Windsurf), and the fact that it can use Anthropic Claude (which far surpassed the default GPT 4o model in term of coding capabilities). That makes Copilot actually useful now.

So I’ve decided to put it to the test. I’m forking my first project!

When you work with opensource softwares, sometimes you’d come across apps that you absolutely love, but there’s this one annoyance that bugged you. When you bring it up in Issues, a common response among the snobby devs is “Well just fork it and implement what you like”, which, in all honestly, is a valid solution. But in the past it is just too much hassle, forking is easy but then you’ll have to read the codebase and see what the environments need and hunt down the dependencies and find where the variables are and change them etc.

Ain’t nobody got time for that!

With agentic AI tools like Copilot Edits, Cursor Composer or Windsurf Cascade, it’s now a breeze. They can analyze the codebase for you and make the necessary changes for you (sometimes even stuffs that you didn’t even ask for, but more on that later)

So for my first attempt, I pick a very simple project that I recently discovered on r/selfhost: TextPod. A dead simple note-taking tool that you can just deploy on your server without any backend db. I’ve always wanted a personal ‘pastebin’ website of sort where you can access from anywhere and paste whatever you want in there so you can access it later either from that device or another device, without having to use a dedicate app or authenticate with a service or anything. TextPod fits my need exactly. There’s only one thing I think it could use some improvements with, the visual styling. Yes I’m a designer after all.

This kind of modification is extremely simple, especially so with TextPod where the entire frontend is contained in a single HTML (with inline CSS and JS).

My takeaways

These days you often see people complaining that AI will dumb us down, and mankind may even forget how to write in the future. For me personally I’ve learned more from this little journey than years of working in the software industry and watching youtube. The AI didn’t just do your job for you, it actually explains what it does in detail and walk you through the steps, which is something most senior developers won’t even bother with you. Throughout this journey I’ve learned:

• How to fork a project
• How to properly embed and implement an UI framework
• How to setup secret variables in Github so I can reference it (for Docker Hub authentication in this case, even though I eventually learned that you need a subscription in order to publish directly to the registry so I switched to ghcr.io instead)
• How Github actions work
• How to publish docker images to Github instead of the registry (always thought ghcr.io was some kind of mirror of the docker registry for some reason lol)

So that concludes my first venture into AI coding. In the future I believe CDEs will eventually replace most IDEs.

IDE = Integrated Development Environment
CDE = Conversational Development Environment or Chatbot Development Environment

We’ll see.