Development on kenji.blog

The Untold Story of LogicPad Development

Wed, 30 Jul 2025 23:51:35 +0900

Tools for those who “have logic but can’t write code.” Why I created LogicPad

Hello, I’m kenji. I’m the creator of the low-code tool “LogicPad”. This time, rather than introducing the product, I’d like to write about the behind-the-scenes of the development—“Why did I decide to make this?"—and my own thoughts from a slightly personal perspective.

To be honest, this was not just another tool development. My past, frustrations at the workplace, skill set, and the smoldering desire to “create my own product someday”— LogicPad was born as a result of all these things overlapping.

In other words, this is my “life’s culmination project.” I’ll write about this background as honestly and passionately as possible.

I wanted a product I could proudly say, “I made this.”

To be frank, this was my very first motivation.

Since a long time ago, I loved writing code for both work and hobbies. I’ve been involved in various developments. But one day, I suddenly realized. “I have no product released into the world under my own name, with my own responsibility.”

Of course, there is value in what you make as a team, and there was plenty of work I could be proud of. But somewhere in my mind, there was a sense of emptiness, wondering, “Am I going to finish my career under someone else’s name like this?”

Just once is enough. I want to leave something behind that I can proudly say, “I made this.” With that thought, I started conceptualizing LogicPad. This was about 6 years ago (around 2019). (The original idea itself came about 10 years ago in 2015 when I learned about Blueprint, the visual programming language of Unreal Engine.)

It’s a waste to hold back just because you can’t write code, isn’t it?

There were many excellent people at my workplace.

They could build logic. They mastered Excel functions freely and could see through to the essence of a problem. But—when it came to the stage of “writing code,” their hands would stop.

“I’m doing this task while looking at a manual every time, but couldn’t it be automated?” “Yeah, it can. But… you’d have to write code for that…”

Conversations like that happened countless times.

Every time, I thought: “It’s such a waste that people who understand the logic get stopped by the wall of code.”

The Choice of a Low-Code Editor

Actually, in my previous job, I was developing a 2D CAD operated by GUI. With CAD, you assemble shapes using a mouse, right? In other words, it’s a world where you “build logic through operations.”

I thought, “This is incredibly compatible with low-code.”

Going back even further, since my student days, I was mass-producing small programs—image processing, numerical processing, Windows tools, automatic SNS posting tools, etc.—by writing code as soon as I thought of them. I think there are over 600 of them. They are still on GitHub today.

Back then, I didn’t think about the meaning. I just “made things because I wanted to make them.” That was it.

But now, while making LogicPad…

I felt like the dots were finally connected into a line.

Easy to Use, Yet Powerful. The Difficulty of Balance

While proceeding with development, what I constantly thought about was “Making a tool that is intuitively usable and genuinely powerful.”

If you add features, you can do more. But it becomes harder to use. If you make it simple, anyone can touch it. But then some people will find it lacking.

So that people won’t say, “Low-code tools are just toys, right?” But also so they won’t say, “You have to write code in the end anyway.”

I fought continuously on that fine line between intuition and expressiveness.

I rebuilt the UI many times, threw it away many times, and when I finally got closer to a form where I thought, “This can work,” I was truly happy.

Saved by the Very First “User’s” Words

The first person I handed LogicPad to was a former colleague. They weren’t good at IT, and code was scary. But they were good at logic.

After I explained a bit and had them try it out… the single phrase they said a few minutes later, I still can’t forget.

“With this, I think even I could do it!”

I almost cried. This was exactly what I wanted to give them.

Not just a working tool, but the feeling of “I made it myself!”. I was convinced that this is the true value of LogicPad.

When More People Can Create, Society Becomes More Interesting

I genuinely believe that the “democratization of technology” is crucial.

Technology has the power to change the world. But the people who can handle it are limited.

What if you could build apps just by “understanding the logic”?

More people will be able to join the “creating side.” And I believe that what gets born from there will exceed our current imagination.

If LogicPad could become that gateway. I want it to be a tool that turns “I want to try making it” into “I can make it.”

That is my wish.

In Conclusion

LogicPad is still in beta and not finished yet. There are a mountain of improvements and things I want to do.

But I’ve poured all the “dots” of my life into this tool. Now, I can say with pride:

“This is a product that I made.”

👇 Bonus: What You Can Do with LogicPad

Build processes with drag-and-drop
Handle conditional branching and variables in the GUI
Features diverse AI integration nodes
Expandable for advanced users by inserting scripts
High-precision mathematical functions and data processing (such as infinite-precision numerical calculations)
Rich shortcut keys for advanced users
Supports over 90 languages

What I Want to Do Moving Forward

Generate logic from natural language in collaboration with AI
A system where users can create custom nodes
Build a platform to share created nodes and logic

✍️ Afterword

Thank you so much for reading this far. This wasn’t just a tool development; it was a challenge into which I poured my own experiences, passion, and fragments of my life.

“I can’t write code, but I have logic.” A future where such people become able to “create” with their own power. I want to continue aiming for that through LogicPad.

If this made you feel even a little bit like “I want to try using it,” that alone makes me very happy. If you’re interested, please definitely try out LogicPad.

And if you have any thoughts or things you noticed after using it, no matter how small, please let me know. Your voice will be a great power in creating the next step for this product.

Thank you for your continued support.

The Wall of AI Development

Sun, 20 Jul 2025 21:52:42 +0900

The Wall of AI Development

〜Made it to the 8th station, but from there it was hell〜

Hello, I’m kenji.

Recently, I’ve been hearing a ton of people saying, “I asked AI and it made an app for me!” We’ve moved past the era of no-code and low-code, and are entering a phase of “vibe coding” (writing code by feel).

For example, if you say, “Make an app that processes images and posts them to SNS,” AI will spit out the code and even the UI. It’s amazing, you’d think we don’t need humans anymore, right?

But you know, that’s like landing at the 8th station of Mount Fuji in sandals.

Getting to the 8th station looks “easy”

Development with AI is really easy at first. File I/O? It runs for now. Network? Well, it connects. Database? JSON is fine. UI? ChatGPT spit out React code. Billing? Just copy-paste the Stripe API.

Here, you get the illusion of “Am I an engineer now?”. But the real hell begins from here.

Why you get stuck

The reason is simple: “AI makes it look like it’s done, but leaves the final adjustments entirely to humans.”

Data gets lost in File I/O
DB normalization is weak so searches are slow
UI is not intuitive
Crashes from access concentration because no load testing was done
Rejected by Apple/Google review
(Almost) causes an uproar by violating legal requirements

In other words, **AI is good at creating a prototype that looks like a finished product , but ** finishing it into a product that actually works in the real world is still a human’s job today.

But there’s a paradox

Here you notice one paradox.

What if AI becomes able to truly do everything in the future? In other words, what if “AI can perfectly handle security, billing, and design all by itself”?

At that time, the need for humanity to create apps itself might disappear.

Because if a user directly tells the AI, “I want to do this kind of thing,” the task will be executed immediately without an app.

🌀For example

In the past, we “launched a calculator app to calculate”, but now it’s done just by saying, “Hey Siri, what’s 12 x 32?”.

In the same way, if you say “AI, process this photo and share it”, the process might be completed without going through any app UI or API.

In other words, when the goal of “making apps with AI” is realized, a world where apps themselves are unnecessary might arrive.

In the end, what we can do now

So, what should we do?

Right now, “above the 8th station” is still the human domain, so polish that
Focus on essential user understanding and service design
Think about “what’s valuable” rather than “what can be made”
Rather, explore ways of providing value that are “not bound by the format of an app”

AI is a tool, a lift, and sometimes a competitor. But, “what to make” and “why to make it” remain questions for us humans.

Conclusion:

The wall of AI development is not a paradox of technology, but of structure

An era where anyone can get to the 8th station of Mount Fuji. But the real thing starts from there.

And by the time we reach the summit, a future might be waiting where we ask ourselves, “Did we even need to climb the mountain?”.

Market-In and Product-Out

Tue, 15 Jul 2025 20:18:22 +0900

Market-In vs. Product-Out

Hello, this is kenji.

Sometimes in business books or proposals,

“We use a market-in strategy.” “This is a product-out approach, isn’t it?”

You see people saying things like this, but…

Wait, market-in? Product-out? Which one is better???

Don’t you ever feel that way?

So this time, I want to break down these terms “market-in” and “product-out” as simply as possible, with a slightly critical eye.

Simply put…

Market-in: Listening to the voice of the market and creating products that match it.
Product-out: Creating what you think is good (the product) and putting it out into the world.

That’s it. Simple.

For example, with a ramen shop…

A market-in ramen shop would be like, “Iekei ramen is popular lately. Alright, let’s go with plenty of fat and garlic!”

A product-out ramen shop would be like, “This soy milk basil salt ramen I made is seriously the best, so eat it.”

Which one is the correct answer… Both are.

With market-in, you cater to customer needs, so “the probability of it selling is high,” but it’s hard to produce breakthrough ideas or innovations.

With product-out, you “give shape to the justice you believe in,” so it’s edgy and attractive, but if you miss the mark, it won’t resonate with anyone.

The iPhone is quite product-out

Apple released the iPhone in an era when people were saying “I don’t need a smartphone.”

This is completely a successful example of product-out.

If they had just listened to users, they would have been told “A phone without a keyboard? Impossible,” and that would have been the end of it.

But product-out can easily become “self-satisfaction”

Sometimes there are companies or people who say, “We are a product-out type,” but

Wait, isn’t that just ignoring the user?

I sometimes think that.

“I made it because I wanted to. But it didn’t sell.” That’s not product-out, that’s “self-indulgent-out.”

Market-in has pitfalls too

On the other hand, market-in is not omnipotent either.

If you say, “I’ll do everything because the users want it!”, the core of the product gets blurred, and in the end, it might not resonate with anyone.

It’s like when you keep adding features, and before you know it, it’s become a chaotic tool.

The ones who are truly amazing are “those doing both”

Amazing products perfectly present “something users truly wanted but couldn’t put into words.”

In other words, it means “getting market-in style empathy with a product-out mindset.”

It’s easy to say, but incredibly difficult to do. However, if you can pull this off, it instantly becomes a “god-tier product.”

Conclusion: User reaction is everything, not words

Market-in or product-out. Which is right is a pretty meaningless question.

“Is it properly reaching the users’ hearts?” That’s everything, I think.

I feel like saying “we’re doing this kind of strategy” is fine as long as you can write it in marketing materials later.

So, that was a talk about market-in and product-out!

Without being confused by weird loanwords, thinking about “In the end, what will make people happy?” is the healthiest approach, I think.

See you around~.

How to Install Gemini CLI on Windows Environment

Sun, 13 Jul 2025 23:49:56 +0900

[For Beginners] How to Install Gemini CLI on Windows

“Gemini CLI” allows you to use Google’s generative AI “Gemini” from the command line. In this article, we will explain the steps to install Gemini CLI in a Windows environment as easily as possible.

1. Preparation: Install Node.js and npm

First, since Gemini CLI runs on an environment called “Node.js”, you need to have the following installed:

Node.js
npm (Package management tool included with Node.js)
npx (Command execution tool included with npm)

Please download the Windows version of Node.js from the official website below (the LTS version is recommended):

👉 Node.js Official Website

Once the installation is complete, let’s verify if it was installed correctly with the following commands.

1
2


node -v
npm -v

2. Launch PowerShell

To use Gemini CLI on Windows, it is common to operate it using PowerShell. Type “PowerShell” in the Start menu to launch it.

3. Install Gemini CLI

Copy and paste the following command into PowerShell and execute it:

1

npx @google/gemini-cli

This command temporarily executes the Gemini CLI package published by Google. You may be prompted for initial setup or login if necessary.

Note: It may take a few minutes the first time. If you encounter an error, please double-check your Node.js or network environment.

4. Installation Complete! What to do next

Now, Gemini CLI has been installed on Windows. From now on, you will be able to perform various operations using Gemini from the command line, such as text generation and code completion.

If you want to check the official documentation or help, you can also utilize commands like the following.

1

npx @google/gemini-cli --help

Conclusion

Let’s review the steps to introduce Gemini CLI to Windows.

Install Node.js and npm
Launch PowerShell
Execute npx @google/gemini-cli

Now you’re all set! If you want to use generative AI locally, please give it a try using these steps as a reference.

Advantages and Disadvantages of Creating Programs with Win32API + C++

Sat, 12 Jul 2025 12:30:35 +0900

The Appeal and Challenges of Developing with Win32API + C++

For those who want to master Windows application development, Win32API + C++ remains a powerful option today. This combination, which allows for interacting with the OS at the closest distance, combines high speed and flexibility.

On the other hand, since it is vastly different from modern development styles, learning it requires dedication.

On this page, from the perspective of an active Windows app developer, we explain its advantages and disadvantages in an easy-to-understand manner.

Advantages

Ultra-Fast Native Execution

Because C++ and Win32API operate at the layer closest to the OS, there is almost no unnecessary overhead. It boasts overwhelming execution speed and highly efficient use of CPU and memory.

High Flexibility and Freedom

You can minutely control all aspects of an application yourself, such as window control, asynchronous processing, COM integration, and process management. It’s also possible to build purpose-built tools and your own custom frameworks.

Easy to Distribute Without Runtimes

Since external runtimes like .NET or Java are unnecessary, it can be distributed as a single executable file. Troubles during redistribution are less likely to occur, and it’s appealing that it can easily run without an installer.

Capable of Creating Lightweight Apps

Because it requires only a bare-minimum configuration, a major feature is its extremely small memory footprint. It runs comfortably even on low-spec PCs or in virtual machine environments.

Advanced OS-Level Control is Possible

Global hooks for mouse and keyboard, fine-tuning of window styles, manipulation of system menus, and other forms of control that are difficult with standard languages and libraries can be realized.

Disadvantages

Low Development Efficiency

GUI construction must also be done entirely in code, and creating a single button can sometimes require dozens of lines of code. Modifications during design changes are also cumbersome, making productivity lower compared to developing with UI frameworks.

Maintainability Tends to Decrease

The code often has a specialized structure, such as message loops and window procedures, leading to issues with readability and reusability. It also has aspects that make it unsuitable for team development and long-term maintenance.

Difficult to Support Modern UI

Supporting UX expected in recent years, such as high DPI support, touch interfaces, accessibility, and dark mode, is difficult. Each must be handled manually one by one, which requires a lot of effort.

No Cross-Platform Support

Because it is a completely Windows-exclusive API, it cannot be ported to macOS or Linux. If you are planning multi-platform deployment, you will need to select other technologies.

Extremely High Learning Cost

You must understand concepts and mechanisms that are rarely used today, such as handles, GDI, COM, and OLE. Much of the documentation is old, requiring time and perseverance to learn.

Suitable Uses

Lightweight tools such as file launchers and hotkey assistants
System utilities like clipboard manipulation and IME control
Native control applications like global hooks and window captures
Driver auxiliary tools that work closely with hardware

Unsuitable Uses

General consumer apps where modern UI/UX is important
Prototyping and MVP development built with a priority on speed
Large-scale projects intended for long-term operation and team development
Cross-platform products that need to support multiple OSs

Evaluation Summary

Aspect	Evaluation
Execution Speed	◎ Very Fast
Memory Efficiency	◎ Excellent
Development Speed	× Slow
Maintainability	× Low
Cross-Platform Support	× Not Supported
Modern UI Support	× Weak
Freedom of OS Control	◎ Overwhelmingly High

Conclusion

Win32API + C++ is a tool suited for developers who want to “handle everything in the OS themselves.” While its power is immense, learning and operating it requires a corresponding level of dedication.

Whether it’s worth “daring to choose” it depends entirely on the nature of the app you are aiming for.

Diving into the world of #include <windows.h> without relying on GUI frameworks or modern languages―― That choice still remains meaningful today.