Agentic coding made programming fun again

Hi, it's Takuya. I have a 9-year-old SaaS with multi-platform desktop and mobile apps called Inkdrop, a plain-text Markdown note-taking app. Recently, I started using Claude Code in my project. My first attempt was a failure, though I eventually got used to it in my workflow.
Then, I recently realized that app development had become fun again. It was unexpected. So, I'd like to share how I adopted agentic coding in my workflow and how it changed my perspective on indie app development.

🎬 Watch Video Version

I had so much technical debt

As you might imagine, maintaining such a long-lived product is super hard.
In the early days, adding new features was a breeze, and everything felt speedy.
However, each time you increase the amount of code, your software grows exponentially more complicated. This means you accumulate a lot of technical debt as your product grows.

My Electron app imported a large part of the code from the Atom Editor to accomplish flexible customizability and high extensibility. So, I managed to quickly provide a comprehensive set of features required for a text editor, even though I am a solo developer, by standing on the shoulders of giants. It was a similar approach to Cursor, a fork of VSCode, for a recent example. However, Atom was unfortunately sunset in 2022. Since then, many dependencies of my app have stopped being maintained. This has been a huge headache for me in keeping my product going. Because replacing obsolete libraries is totally not fun, and besides, it doesn't provide additional value for users. The amount of required workload seemed too large for me alone.

I nearly gave it up... Then, recently, Claude Code and other AI CLI tools emerged.
This changed the game entirely for such a long-running product. Let me share how I got into the AI tools.

You have to practice how to ride a bicycle

Since everyone was praising AI tools, I assumed it should be easy to adopt for an experienced developer. But I was wrong. About a month ago, I tried using Claude Code to build a simple tool, but failed miserably.

I tried a one-shot prompt to build a complete project. Claude Code kept generating wrong code, broken code, and unexpected code. I realized that without careful prompts, context management, or deep oversight, vibe coding could easily lead to dysfunctional code.

Let's say riding a bicycle looks simple and easy, but it actually requires you to practice. So do AI Agents.

Here's what I learned from feedback in the comments (Thanks):

1. Don't go in blindly – plan well:
   • Define a detailed spec and break it into small deliverables.
   • Tackle one task at a time.
   • Use unit tests to verify each part before moving on.
   • Ask Claude to help craft prompts as well—prompt engineering matters.
2. Vibe coding works best when:
   • Used for boilerplate, small automation, legacy code, or tasks you don't care to write by hand.
   • You treat Claude as a helper or worker, not as a lead developer.
3. Don't replace yourself – augment yourself:
   • The better you understand what you're doing, the less vibe coding you'll want to do.
   • AI is good at execution, not intuition. Use it to speed up, not take over.
4. Start with a clear structure:
   • Begin with a todo list or roadmap.
   • Separate work into phases: e.g., scaffolding → features → tests → polish.
5. Manage expectations:
   • AI struggles with:
     • Large or complex codebases.
     • Fine-grained control over behavior.
     • Non-standard tools or stacks (e.g. Bun + SQLite).

And I've read some articles:

• Field Notes From Shipping Real Code With Claude - diwank's space
• How I Use Claude Code | Philipp Spiess
• Claude Code is My Computer | Peter Steinberger
• Agentic Coding Recommendations | Armin Ronacher's Thoughts and Writings

In the next attempt, I successfully built a RAG tool for myself with Claude Code!

Since then, I've often been using Claude Code as my coding assistant, like an intern developer.

Let AI work on boring tasks, and enjoy fun tasks

The key to using AI Agents I realized is: Motivation. It helps you stop procrastinating on boring tasks. As mentioned, AI is pretty good at doing tasks that many people have done in the past. If there is a boring task such as boilerplate, small automation, legacy code, or one you don't care to write by hand, AI can solve it pretty quickly and neatly. And I found myself feeling so good after finishing these tasks using AI. It frees up my working memory. I have fewer headaches.

So, in my case, I had too many boring but inevitable tasks to do due to the deprecation of the Atom Editor. For example, there are two important parts:

• ipm - Inkdrop Package Manager. Originally forked from apm.
• Build pipeline: While most recent Electron apps use Electron Builder or Electron Forge, Inkdrop was still using its own custom build pipeline originally from Atom.

These two parts depend on each other. So, I had to migrate them at the same time. Feeling down – I had been procrastinating on that. However, I won't explain the details here, but I managed to replace the old ipm with a modern and simpler implementation, and managed to replace the bloody complex custom build pipeline with Electron Builder by letting Claude Code analyze it, plan the migration steps, and create boilerplate. For example, here is an analysis and migration plan that Claude Code created:

Migrate to the standard build tool for Electron

- Candidates: - electron-builder - @electron-forge ## Current Build System Analysis Inkdrop currently uses a **custom Grunt-based buil

This helped me a lot to grasp the overview of the work. There was some old and misinformation in it, but I could fix it by letting it read the docs.

This was a life-changing experience for me.

AI is like a bullet train – It's basically for common tasks

Some people say AI is useful and some people disagree – I think that's because they don't understand its characteristics. AI generates code so fast that you might think coding is no longer a bottleneck, then reviewing it becomes a new bottleneck.
This is a common misunderstanding of AI.

Think of AI as a bullet train. You can get to popular cities pretty fast. However:

• You can't enjoy the views closely from the train because it's too fast
• You can't get to the exact place you want to go, but just to the large hub stations

You only have a few seconds to enjoy Mt. Fuji from Tokaido Shinkansen. You still have to transfer to a local train, bus, or taxi to visit specific places.

Similarly, AI tools don't let you:

• look into details that AI generated because it's too fast
• create the exact thing you imagine because it can't infer your thoughts perfectly

You can't understand the process of why AI ended up generating the result code.
Especially if you are not familiar with the language the AI outputs, it is impossible to understand the details. To improve the quality, you still have to fix minor errors, adjust spacing, wording, and refactor the code structure.

You will notice that those who over-praise AI tools do just what AI tools are good at: Get you to a popular place like a bullet train. People who dislike AI tools try to see Mt. Fuji closely from a bullet train, which is impossible as well.
Since AI is just a tool, like Shinkansen, you still need other tools or manual coding to make exactly what you want.

So, our bottleneck hasn't changed: Your creativity and craftsmanship. No matter how AI gets smarter, our organic skills always matter.

I'm excited about this. While letting AI do chores and boring tasks, I can enjoy adding new features and implementing novel things that AI doesn't know yet.
What do you think?

Looking for a Markdown note-taking app designed for developers? Check it out:

Inkdrop - Note-taking App with Robust Markdown Editor

The Note-Taking App with Robust Markdown Editor

Inkdrop logo