Aperture is an open-source AI code editor that runs five checks on every change before writing it to disk
Aperture is an MIT-licensed AI code editor whose Composer stages a diff, runs parsing, imports, type checking, preview rendering and tests in a sandboxed Worker, and only writes the change if the five pass.

Why it mattersAn agent that confirms its own change before committing it to the tree is the first version of this workflow that stops producing a stream of broken diffs for the human to clean up.
An AI code editor that proposes a change and leaves the user to check whether it compiles is a worse version of what it is replacing.
Aperture, launched on Product Hunt on 5 October 2026, is a free open-source AI code editor that checks its own work before applying any change. The Composer plans a code modification and stages it as a diff. Before the diff is written to disk, Aperture runs five verification checks: parsing, import resolution, type checking, preview rendering, and test execution. If a test fails after the proposed edit, the agent gets one retry; if that fails, the change stays staged for a human to look at. The project is MIT-licensed, lives at Hankaws/aperture on GitHub, and ships with support for Grok, OpenAI, Anthropic, Gemini, DeepSeek and custom endpoints. The author is Witchayut (@hankaws).
The five checks, in order
Each one answers a different question about the proposed diff:
- Parsing confirms the resulting file is still syntactically valid.
- Import resolution confirms every symbol the diff introduces or renames resolves to something that exists.
- Type checking confirms the diff does not break the project's types.
- Preview rendering confirms a UI change still renders, not just compiles.
- Test execution runs the relevant tests inside a sandboxed browser Worker.
The last one is the piece most agent IDEs do not do today. Tests run in a sandboxed Worker rather than against the user's machine or an external runner, which means they cost nothing to run and do not require the user to configure a test runner before they can use the feature.
The retry policy, and why it matters
The one-retry rule is a design choice, not a limitation. An agent that fails a check and keeps retrying forever is the pattern that burns a budget on a loop that was never going to converge. One retry gives the agent room to try an obvious correction (a missing import, a renamed symbol) and nothing more. If the second attempt fails too, the diff stops being treated as the agent's output and starts being treated as a review item for the user.
That stops two failure modes at once. It stops the agent from reaching a successful parse by writing increasingly nonsensical code, and it stops the user from receiving a successful-looking green pass on code the agent silently rewrote three times.
The two caveats that come with it
The checks only answer questions the project is set up to answer. A project with no tests gets no test gate; a project with no types gets no type-check gate. Aperture is a stronger version of the workflow in a well-set-up repository, and a weaker version in a repository that would benefit from it most.
And the free offer runs on the user's own machine. The demo on the launch page plays recorded runs; a real session on real code needs the user to self-host locally or deploy with their own API keys for the model provider they prefer.
Source
- Aperture on Product Hunt, launched 5 October 2026.
This item was written by an AI system from the linked source. Reveneau is responsible for what it publishes.
Get AI News in your inbox
New developer tools, model and agent releases, and how teams are actually using them to release software. Short, and only when there is something worth reading.