Recently, while working on my personal projects, I've been noticing something.
I have so many ideas I want to try. Thanks to generative AI, I can write code much faster than before.
And yet── overall development speed hasn't improved as much as I expected.
This disconnect led me to start building DevLoop Runner.
Conversational AI is Great. But You're Still Stuck on One Screen
The development experience with tools like Claude Code and Cursor is genuinely excellent.
- You can build through conversation
- They assist your thinking
- The implementation quality is high
However, as I continued with personal development, I noticed a limitation.
In the end, you give one instruction, wait for a response, review it, then move to the next.
Wait times accumulate in small chunks, and it's surprisingly difficult to work on something else during those intervals.
As a result:
- Work only progresses sequentially
- You still spend the same amount of time glued to the screen
"Maybe AI just replaced the person typing, but the actual development workflow hasn't changed at all?"
That's what I started thinking.
In Personal Projects, We Avoid "Implementations That Might Fail"
There's another issue specific to personal development.
We hesitate to spend time on development that might not pay off.
- "I want to build this prototype"
- "But I'm not sure if it'll work"
- "If it fails, I'll feel like I wasted my time"
This leads us to unconsciously abandon ideas we actually want to try.
The result:
- We only choose safe implementations
- "Experimentation" and "adventure" disappear
This isn't a technical problem──it's a psychological cost problem.
What I Really Wanted: Development Where You Can "Try Things in Parallel"
That's when I came up with this idea:
Humans think. AI moves in parallel, behind the scenes.
What if we could:
- Run Issues A, B, C, D simultaneously
- Leave them for a while
- Review all the PRs together later
And then:
- Merge if good
- Revise if needs work
- Simply close if it doesn't work out
Even if it fails, there's no regret.
This way, we could more freely include "small experiments" and "playful implementations."
This was the starting point for DevLoop Runner.
What I Want to Delegate to AI Isn't "Constant Checking" but "Parallel Execution"
There are tools out there where AI autonomously drives development.
Those are appealing in their own way, but what I wanted was slightly different.
With DevLoop Runner:
- Start from a GitHub Issue
- AI handles requirements, design, implementation, and testing
- Delivers results as a Pull Request
The key here is:
You can choose when to check.
- You can review at the design stage before proceeding to implementation
- You can review everything together at the final PR stage
In other words:
I don't want to hand over development entirely to AI. I just want to delegate parallel execution.
The premise is a division of roles: humans focus on review and decision-making.
Creating a System Where "It's Okay to Fail"
What I consider most valuable about this tool isn't the implementation speed itself.
Making it less scary to try things out.
- Write an Issue for a prototype
- AI implements it automatically
- If it doesn't fit, just close it
That's it.
You don't have to bet your time and mental energy on "implementations that might fail."
Just having this psychological safety can significantly change how personal development works.
For Those Facing Similar Challenges
- You're using AI coding tools, but things aren't as fast as expected
- Issues keep piling up, and you're carrying everything yourself
- You have ideas you want to try but can't take the leap
If any of this resonates with you, the concept of "trying things in parallel" is worth experiencing at least once.
DevLoop Runner is still evolving and requires initial setup (like GitHub tokens).
Even so, if you think:
"This direction sounds kind of interesting"
I encourage you to try creating an Issue.
Closing Thoughts
Now that AI can write code, what needs to change next might not be development speed, but development courage.
- Humans think
- AI runs in parallel
- It's okay to fail
I'm gradually experimenting with this style of development.
DevLoop Runner: https://devloop-runner.app/
Top comments (0)