u/Proof_Juggernaut1582

Over the past few months I've been building an open-source desktop application called Limboo, and I wanted to share the idea behind it because I'm curious whether anyone else has been running into the same problems.

One thing I've noticed with AI coding tools is that they're incredibly good at writing code, but once a project becomes large, the actual engineering workflow still feels fragmented.

The AI is usually in one window.

Git is somewhere else.

The terminal is somewhere else.

Build logs are somewhere else.

Documentation is in another browser tab.

Project decisions are spread across old conversations.

The longer I work on something, the more time I spend rebuilding context instead of actually building software.

That observation is what started Limboo.

The goal isn't to replace coding agents like Claude Code, Codex, or other agent-based tools.

I actually want to use those.

The idea is to build everything around them.

Instead of treating the AI as the entire application, Limboo treats it as one component inside a much larger engineering workspace.

Every task becomes its own isolated session.

Each session has its own conversation history, terminal state, Git branch or worktree, checkpoints, permissions, local memory, search index, execution timeline, and task list.

If I stop working on a feature today and come back in two weeks, I don't want to explain everything again.

I want to reopen the session and continue exactly where I left off.

Another thing I wanted to improve is transparency.

I don't like when an agent runs commands that disappear into a log somewhere.

If it's running a build, I want to watch the build.

If it's modifying files, I want to see the diffs while it's working.

If it wants approval, I don't want a giant modal that interrupts everything—I want approvals to appear naturally inside the conversation stream.

Planning is another area I'm spending a lot of time on.

Instead of generating a plan that disappears after one response, the plan becomes a living task board.

Once it's approved, the agent starts implementing those tasks while updating their progress in real time.

Git is also treated as a first-class part of the workflow instead of an afterthought.

Every change is visible through diffs, checkpoints, snapshots, commit previews, and history before anything gets committed.

The goal is to make it obvious what changed, why it changed, and which conversation produced those changes.

I'm also experimenting with isolated Git worktrees so multiple sessions can work on completely different features without stepping on each other.

Another area I'm investing in is local memory.

Rather than asking the agent to rediscover architecture decisions, coding conventions, and previous implementations every session, the application stores that knowledge locally and retrieves only what's relevant before each request.

Everything is designed around long-running software projects instead of one-off prompts.

The stack is Electron on the desktop, Rust for native services, and AI agents orchestrated through the Claude Agent SDK.

It's still very much a work in progress, and I'm sure there are plenty of design decisions I'll end up changing as I build more of it.

I'd genuinely appreciate feedback from people who use AI coding tools every day.

I'm especially interested in hearing what parts of your workflow still feel disconnected, because that's really the problem I'm trying to solve.

Repository: https://github.com/BotCoder254/limboo

I'd love to hear what you think—both the good and the bad.

Over the past few months I've been building an open-source desktop application called Limboo, and I wanted to share the idea behind it because I'm curious whether anyone else has been running into the same problems.

One thing I've noticed with AI coding tools is that they're incredibly good at writing code, but once a project becomes large, the actual engineering workflow still feels fragmented.

The AI is usually in one window.

Git is somewhere else.

The terminal is somewhere else.

Build logs are somewhere else.

Documentation is in another browser tab.

Project decisions are spread across old conversations.

The longer I work on something, the more time I spend rebuilding context instead of actually building software.

That observation is what started Limboo.

The goal isn't to replace coding agents like Claude Code, Codex, or other agent-based tools.

I actually want to use those.

The idea is to build everything around them.

Instead of treating the AI as the entire application, Limboo treats it as one component inside a much larger engineering workspace.

Every task becomes its own isolated session.

Each session has its own conversation history, terminal state, Git branch or worktree, checkpoints, permissions, local memory, search index, execution timeline, and task list.

If I stop working on a feature today and come back in two weeks, I don't want to explain everything again.

I want to reopen the session and continue exactly where I left off.

Another thing I wanted to improve is transparency.

I don't like when an agent runs commands that disappear into a log somewhere.

If it's running a build, I want to watch the build.

If it's modifying files, I want to see the diffs while it's working.

If it wants approval, I don't want a giant modal that interrupts everything—I want approvals to appear naturally inside the conversation stream.

Planning is another area I'm spending a lot of time on.

Instead of generating a plan that disappears after one response, the plan becomes a living task board.

Once it's approved, the agent starts implementing those tasks while updating their progress in real time.

Git is also treated as a first-class part of the workflow instead of an afterthought.

Every change is visible through diffs, checkpoints, snapshots, commit previews, and history before anything gets committed.

The goal is to make it obvious what changed, why it changed, and which conversation produced those changes.

I'm also experimenting with isolated Git worktrees so multiple sessions can work on completely different features without stepping on each other.

Another area I'm investing in is local memory.

Rather than asking the agent to rediscover architecture decisions, coding conventions, and previous implementations every session, the application stores that knowledge locally and retrieves only what's relevant before each request.

Everything is designed around long-running software projects instead of one-off prompts.

The stack is Electron on the desktop, Rust for native services, and AI agents orchestrated through the Claude Agent SDK.

It's still very much a work in progress, and I'm sure there are plenty of design decisions I'll end up changing as I build more of it.

I'd genuinely appreciate feedback from people who use AI coding tools every day.

I'm especially interested in hearing what parts of your workflow still feel disconnected, because that's really the problem I'm trying to solve.

Repository: https://github.com/BotCoder254/limboo

I'd love to hear what you think—both the good and the bad.

Over the past few months I've been building an open-source desktop application called Limboo, and I wanted to share the idea behind it because I'm curious whether anyone else has been running into the same problems.

One thing I've noticed with AI coding tools is that they're incredibly good at writing code, but once a project becomes large, the actual engineering workflow still feels fragmented.

The AI is usually in one window.

Git is somewhere else.

The terminal is somewhere else.

Build logs are somewhere else.

Documentation is in another browser tab.

Project decisions are spread across old conversations.

The longer I work on something, the more time I spend rebuilding context instead of actually building software.

That observation is what started Limboo.

The goal isn't to replace coding agents like Claude Code, Codex, or other agent-based tools.

I actually want to use those.

The idea is to build everything around them.

Instead of treating the AI as the entire application, Limboo treats it as one component inside a much larger engineering workspace.

Every task becomes its own isolated session.

Each session has its own conversation history, terminal state, Git branch or worktree, checkpoints, permissions, local memory, search index, execution timeline, and task list.

If I stop working on a feature today and come back in two weeks, I don't want to explain everything again.

I want to reopen the session and continue exactly where I left off.

Another thing I wanted to improve is transparency.

I don't like when an agent runs commands that disappear into a log somewhere.

If it's running a build, I want to watch the build.

If it's modifying files, I want to see the diffs while it's working.

If it wants approval, I don't want a giant modal that interrupts everything—I want approvals to appear naturally inside the conversation stream.

Planning is another area I'm spending a lot of time on.

Instead of generating a plan that disappears after one response, the plan becomes a living task board.

Once it's approved, the agent starts implementing those tasks while updating their progress in real time.

Git is also treated as a first-class part of the workflow instead of an afterthought.

Every change is visible through diffs, checkpoints, snapshots, commit previews, and history before anything gets committed.

The goal is to make it obvious what changed, why it changed, and which conversation produced those changes.

I'm also experimenting with isolated Git worktrees so multiple sessions can work on completely different features without stepping on each other.

Another area I'm investing in is local memory.

Rather than asking the agent to rediscover architecture decisions, coding conventions, and previous implementations every session, the application stores that knowledge locally and retrieves only what's relevant before each request.

Everything is designed around long-running software projects instead of one-off prompts.

The stack is Electron on the desktop, Rust for native services, and AI agents orchestrated through the Claude Agent SDK.

It's still very much a work in progress, and I'm sure there are plenty of design decisions I'll end up changing as I build more of it.

I'd genuinely appreciate feedback from people who use AI coding tools every day.

I'm especially interested in hearing what parts of your workflow still feel disconnected, because that's really the problem I'm trying to solve.

Repository: https://github.com/BotCoder254/limboo

I'd love to hear what you think—both the good and the bad.

Over the past few months I've been building an open-source desktop application called Limboo, and I wanted to share the idea behind it because I'm curious whether anyone else has been running into the same problems.

One thing I've noticed with AI coding tools is that they're incredibly good at writing code, but once a project becomes large, the actual engineering workflow still feels fragmented.

The AI is usually in one window.

Git is somewhere else.

The terminal is somewhere else.

Build logs are somewhere else.

Documentation is in another browser tab.

Project decisions are spread across old conversations.

The longer I work on something, the more time I spend rebuilding context instead of actually building software.

That observation is what started Limboo.

The goal isn't to replace coding agents like Claude Code, Codex, or other agent-based tools.

I actually want to use those.

The idea is to build everything around them.

Instead of treating the AI as the entire application, Limboo treats it as one component inside a much larger engineering workspace.

Every task becomes its own isolated session.

Each session has its own conversation history, terminal state, Git branch or worktree, checkpoints, permissions, local memory, search index, execution timeline, and task list.

If I stop working on a feature today and come back in two weeks, I don't want to explain everything again.

I want to reopen the session and continue exactly where I left off.

Another thing I wanted to improve is transparency.

I don't like when an agent runs commands that disappear into a log somewhere.

If it's running a build, I want to watch the build.

If it's modifying files, I want to see the diffs while it's working.

If it wants approval, I don't want a giant modal that interrupts everything—I want approvals to appear naturally inside the conversation stream.

Planning is another area I'm spending a lot of time on.

Instead of generating a plan that disappears after one response, the plan becomes a living task board.

Once it's approved, the agent starts implementing those tasks while updating their progress in real time.

Git is also treated as a first-class part of the workflow instead of an afterthought.

Every change is visible through diffs, checkpoints, snapshots, commit previews, and history before anything gets committed.

The goal is to make it obvious what changed, why it changed, and which conversation produced those changes.

I'm also experimenting with isolated Git worktrees so multiple sessions can work on completely different features without stepping on each other.

Another area I'm investing in is local memory.

Rather than asking the agent to rediscover architecture decisions, coding conventions, and previous implementations every session, the application stores that knowledge locally and retrieves only what's relevant before each request.

Everything is designed around long-running software projects instead of one-off prompts.

The stack is Electron on the desktop, Rust for native services, and AI agents orchestrated through the Claude Agent SDK more To be supported soon.

It's still very much a work in progress, and I'm sure there are plenty of design decisions I'll end up changing as I build more of it.

I'd genuinely appreciate feedback from people who use AI coding tools every day.

I'm especially interested in hearing what parts of your workflow still feel disconnected, because that's really the problem I'm trying to solve.

Repository: https://github.com/BotCoder254/limboo

I'd love to hear what you think—both the good and the bad.

This is very sad like the camera it's clear like they did it may the fallen soldier 😔 Rest in peace