KForge

KForge is an AI engineering workbench that helps developers safely evolve existing applications through guided edits, previews, and iterative collaboration instead of one-shot code generation.

Comment

KForge

Inspiration

KForge started because I kept running into the same problem while building applications with AI. AI could often produce a good first version of an app, but continuing the project was much harder.

I wanted something where I could make a controlled change, test it, and continue without destroying previous work. That became the idea behind KForge: a local-first desktop AI engineering workbench where the developer stays in control.

KForge was not created during OpenAI Build Week. I have been developing it through AI-assisted coding for approximately six months. Build Week encouraged me to document the project properly, review how it had developed, and focus again on its most difficult problem: reliable editing of an existing application.

What KForge does

KForge brings several parts of an AI-assisted development workflow into one Windows desktop application.

It currently allows users to:

  • Create and open local project workspaces
  • Set up starter projects through a guided workflow
  • Choose a visual direction and theme during the initial build
  • Configure different AI providers and models
  • Attach the current file to an AI request
  • Work with project files and previews
  • Run terminal commands inside the active project
  • Use a guided library of common terminal commands
  • Keep development local and Git-friendly
  • Review and control AI-assisted changes

KForge currently supports provider configuration for OpenAI, Anthropic, Google Gemini, and OpenRouter. Add Groq, Mistral, local runtimes (Ollama, LM Studio) and custom enpoint (openAI compatible)

The longer-term goal is not just to generate applications. It is to make repeated AI-assisted changes to existing applications easy, error free, and recoverable.

That part of the project is still being stabilised. I have deliberately described it as experimental rather than presenting unfinished work as a completed feature.

How I built it

KForge is a Windows desktop application built with React, JavaScript, Tauri 2, Rust, Node.js, and pnpm.

I built it incrementally, usually taking one problem at a time. A feature was inspected, implemented, tested in the real application, and then committed to Git once it reached a stable point.

Over the project’s development, OpenAI models including GPT-5.4-mini, GPT-5.4, GPT-5.5, and GPT-5.6 were used at different stages for architecture discussions, debugging, implementation guidance, UX refinement, documentation, and testing strategies.

Codex was also used recently, as a second engineering assistant. It helped inspect the repository, review proposed changes, suggest focused patches, identify risks, and check implementation work. During testing, Gemini and Claude were occasionally used to rule our a model issue.

The AI tools did not independently build or manage the project. I reviewed the suggestions, decided what should be changed, ran the tests, checked the real behaviour, and controlled the Git history and releases.

Challenges

The hardest challenge has been reliability.

An AI response can look correct while still being unusable. It may contain malformed tool instructions, refer to the wrong file, repeat an earlier failed approach, or change more of the application than requested.

That meant KForge needed more than a prompt box connected to a model.

I had to work on problems such as:

  • Detecting responses that did not contain a usable edit request
  • Recovering from malformed or unexpected model output
  • Inspecting the current project before attempting a change
  • Making sure terminal commands run from the correct project folder
  • Preserving quoted command arguments correctly
  • Keeping previews and settings visually separated and predictable
  • Preventing hidden project context from unexpectedly influencing an edit
  • Understanding the different states involved when changing an existing application
  • Making failed operations understandable rather than silently continuing

Some of the most useful progress came from failures. When a workflow broke, I tried to understand whether the problem came from the model, the prompt, the project context, the edit state, or KForge itself.

The existing-application edit workflow is still the biggest challenge. During testing, I found that adding more context and more controls did not automatically make the system more reliable. In some cases, simplifying the workflow gave a clearer path forward.

What I learned

The biggest lesson was that AI-assisted software development is not only about model intelligence.

A strong model can still fail if the surrounding workflow gives it unclear context.

Another important lesson was that more features do not always create a better tool. KForge has sometimes improved by removing controls, simplifying screens, and narrowing the active workflow.

Building KForge also changed how I work with AI. Instead of asking for large uncontrolled changes, I now prefer smaller stages, clear outcomes, real testing, and stable Git checkpoints.

OpenAI Build Week

For OpenAI Build Week, I used GPT-5.6 and Codex during the latest phase of KForge’s development.

This work focused on:

  • Reviewing the existing-application editing workflow
  • Investigating edit-state transitions
  • Improving controlled-edit recovery
  • Inspecting and reviewing implementation changes
  • Testing the current product
  • Expanding the README and project documentation
  • Preparing an honest demonstration of KForge’s current capabilities

Build Week did not represent the beginning of KForge. It provided a reason to create a clear milestone and show the project as it currently exists, including both its working features and the areas still under development.

What is next

The next major goal is to make repeated edits to an existing application reliable.

That means creating a simpler and clearer edit state, improving project inspection, validating model responses before they are applied, and making recovery predictable when a request fails.

After that, I plan to continue improving provider support, testing, documentation, and eventually platform support beyond Windows.

KForge is still an early-stage project, but it has already taught me that the hardest part of AI coding is not generating the first app. It is helping someone safely build various apps to solve various problems in various environment.

Built With

Share this project:

Updates

Submission history