r/OnlyAICoding

[effacé]

Quick backstory: I'm not a developer. No CS degree, never written a line of Swift before this. But I kept missing return deadlines, forgetting free trials before they turned into paid subscriptions, and losing track of invoice due dates — so instead of just complaining about it, I decided to try building the fix myself using Claude Code (Anthropic's AI coding tool) as my actual dev partner.

The result is Untilly: you photograph a receipt, contract, invoice, or trial confirmation (or upload it as a PDF), it detects the relevant date, and reminds you before it's too late. A few decisions I made early on:

The AI only ever suggests a date — you always confirm it against the real document before it's saved. I didn't want a "trust the black box" tool for something people rely on.
No account, no cloud, everything stays on your phone.

Different wording for different situations (a return deadline feels different from a trial about to charge you, so the app treats them differently).
What surprised me building this without a coding background: the app itself came together faster than I expected, but everything around it — App Store Connect, subscription setup, tax forms, privacy questionnaires — ate at least as much time as the actual product. Nobody warns you about that part.
I also tried adding a Share Extension (send a PDF straight from Mail/Files into the app) and had to abandon it after fighting an entitlements bug for hours — sometimes you just cut scope and ship what works.

It's live now on the App Store, free to try with a few tracked items, optional premium for unlimited: https://apps.apple.com/app/id6792659522

Curious whether other non-technical folks here have tried building with AI tools instead of learning to code or hiring out — did it actually hold up once you got past the prototype stage?

Hey everyone,

I'm currently building Auvrith, an AI-powered engineering platform aimed at helping developers work smarter and ship better software.

I'm still in the building/pre-launch stage, so I'm not here to pretend it's a finished product. I'm actually looking for feedback from developers before I take it further.

Right now, I'm working on things like:

• AI-assisted engineering workflows
• Developer productivity
• Understanding and working with software projects
• A clean workspace for engineering tasks

One thing I've realized while building it is that making an AI tool isn't necessarily the hard part — making something developers would genuinely want to use every day is.

So I'd really like to hear from developers here:

What is one thing you wish current AI coding/engineering tools did better?

It could be anything — accuracy, understanding large codebases, debugging, context, workflow, reliability, UI, or something completely different.

I'm collecting feedback now and using it to shape Auvrith before opening it up to early users.

The link for the Waitlist website is here

Thanks! 🙌

Please mail me at pranavkishore9@gmail.com if you have any question

I've been using T3 Code for a while and genuinely love its UI — the chat view, the workflows, the whole feel of it.

Then I discovered omp (oh-my-pi) and it was a wake-up call. My agents just feel powerful with it. The way it hands them tools, the rewriting hooks, the whole setup — they work so much better.

Problem: I missed the T3 Code experience. So I decided to marry the two.

I forked T3 Code and heavily modified it to run specifically on omp (omp --mode rpc). Stripped it down to omp only, added managed omp install and account login right in Settings. Bringing the omp functionality into the ui of t3 code and calling it pivot. Also thought about the name t3.14 but did not end up going with that name.

It's alpha. Rough around the edges, needs a lot of work. But I've been using it as my main driver for a couple days now and honestly? Really enjoying it. Figured I'd share it.

GitHub: https://github.com/13kparkin/Pivot

Edit: I know there are other gui wrappers out there for this type of thing but nothing that quite felt right for me like t3code does.

There are hundreds of vibe coded apps being released every day, and some are amazing. And some are hot garbage. This is a place to post them and let the world decide.

There are no accounts to make, just post your app and save the post-submission link if you ever want to edit it. Otherwise, that's it!

https://slopornot.simplicated.dev

Cheers!

Problem

Like any side project, Remarc started with my own problem: there was no good way to give AI coding agents contextual feedback on their own output.

There are plenty of tools for collaborating with humans, but surprisingly few for collaborating with AI. Chat was not cutting it for the feedback I wanted to give:

This thing in the implementation plan? Change it to that. What did you mean here? See this button? Here is a screenshot. I circled it because it is missing a hover state. This sentence in the third paragraph? Rephrase it.

If you are an opinionated builder, this gets clunky quickly. You either dictate paragraphs of messy feedback or resolve every detail one by one. AI is good at parsing mess, but garbage in, garbage out still applies.

I could get products to 90% quickly. The last 10% of feedback and polish was the bottleneck. So I built Remarc.

Remarc lets you select text in any Mac app, capture and annotate a screenshot, or comment on a web element. Each comment keeps its original context, status, and session. A connected agent can read the session, work through it, update statuses, and leave resolution summaries over MCP.

Think of it like leaving comments on a google doc vs sending a long rambling feedback note via Slack - the more granular you get with your feedback, the more it benefits from structure & better context.

Comparison

The closest tools I found are CuePin, which focuses on annotated screenshot handoff, and Agentation, which focuses on web UI feedback. Remarc combines those workflows across macOS: selected text, screenshots, and web elements in one persistent session on an OS-level that your agent can read and update.

It also includes exports and webhooks if you want to customize the handoff.

Pricing

$0. Remarc is free and open source, with no account, subscription, or telemetry. It requires macOS 14 or later.

Download: https://remarc.app
Source: https://github.com/metedata/Remarc

About the developer

I’m Mete, the developer of Remarc. I'm also the developer of Relinq which debuted on this subreddit.

Github: https://github.com/metedata
LinkedIn: https://www.linkedin.com/in/mete-polat/
Contact: mete@metedata.com, Metedata LLC
Privacy Policy: https://docs.remarc.app/reference/data-and-privacy/

Hey, I'm a webdev. I previously approached my project with JavaScript. I'm familiar with the js ecosystem.

I put a fair bit of consideration and in contrast to my JavaScript-approach, I'd like to investigate Dioxus.

I'm not completely new. I've dabbled in Rust before. I have read a lot of the docs and I'm sure there is much more to learn and practice.

What advice would you give to getting started with the Rust ecosystem approach?

Similar to a lot of languages there are considerations for things like tests. So it would be helpful to compare the options. As well as any other best-practices and nuances.

In relation to my project, I'm particularly interested in the tooling available in Rust for formal verification.

---

Just to be clear, im not here to waste your time on my slop, but if you want to see what I've got so far (practically nothing):

• Code: https://github.com/positive-intentions/whatsup
• Demo: https://positive-intentions.github.io/whatsup

I'm looking for vibe coders and AI builders to join my newly launched platform vibescore.dev .

It has a leaderboard for verifiable build data based your actual claude/codex usage:

- API-equivalent cost

- active build time

- tokens burned

You can track your build cost over time by adding snapshots of every new version launch.

As early builders you get:

- an opportunity to rank at the top

- an opportunity to put your app in front of potential users and other builders

- a "founding shipper" status on your profile that you keep forever

The submission takes 2 easy steps, you run a cli cmd and paste your url and it will autofill everything for you

You can also comment your app below and I will add it for you to claim later

Link: https://vibescore.dev

I'm a software developer (professionally for last 25 years) and got hooked on coding agents as the next guy.

I built https://github.com/enola-labs/enola as architecture intelligence for developers, coding agents and CI. You can see how and what it does as part of CI on that repo itself: https://github.com/enola-labs/enola/actions/runs/30579279230/job/90995180445

I use it daily, and you can add the hook so it does what it is best in: before agent starts editing it uses it to pin the state, after editing is done it checks what it did, so that it can self correct if and when needed.

Me and bunch of friends are using it, and most of stuff I built is based on their feedback and stuff they needed.

Happy to get the feedback from anyone who ends up using it. Also, if the language you need is not there, let me know and I will add it.

Most agents today are already pretty powerful and requires minimum prompt engineering, and the app builder's value was in the easy set up. So I made an MCP that does what lovable/replit do, but uses your AI subscription's tokens instead. It ends up being a 60+ tool MCP but it's been working pretty well. It does require a good model (opus or terra) to work well, but overall it's been able to do a pretty good job.

Check it out here: https://floot.com

And let me know if you have any feedbacks!

Hi everyone,

I've been building an open-source project called Kodiak.

The goal of Kodiak is to become an autonomous AI software engineering platform that can:

• Understand an entire codebase

• Build a semantic repository index

• Retrieve relevant context using RAG

• Plan multi-step development tasks

• Execute tools safely

• Learn from previous executions

• Improve through reflection and memory

Current progress:

✅ Repository indexing

✅ Semantic search

✅ Embedding pipeline

✅ RAG retrieval

✅ Memory system

🚧 Workflow engine

🚧 Multi-agent orchestration

My current focus is making the architecture modular so future components (planner, coding agents, memory, tool execution, GitHub integration) can evolve independently.

I'm not looking for someone to build the project for me.

Instead, I'd really appreciate feedback from developers who have built AI agents, developer tools, or large Python systems.

I'd especially love opinions on:

• Overall architecture

• RAG pipeline design

• Repository indexing strategy

• Memory architecture

• Scalability concerns

• Features that would make Kodiak genuinely useful

GitHub:

https://github.com/ShamGaneshan2008/Kodiak

Any honest feedback—positive or critical—is appreciated. I'm building this to learn how large AI systems are designed, so I'd love to hear from experienced engineers.

Thanks!

I work at a French AI company, and internally we’ve built our own agentic coding system for most of our software development.

We no longer use Claude Code, Codex, Cursor, OpenCode, etc. as our primary workflow.

It started as an internal experiment, but it has been a real game changer for us in terms of **cost, efficiency, consistency and quality**. We’re now considering turning it into an open-source project.

The core idea is pretty simple:

**1. The system builds itself around your project**

There is **no universal agent configuration**.

For an existing project, it audits the repository: architecture, stack, conventions, needs, permissions, risks, etc.

For a brand-new project, you can simply describe what you want to build, and it creates the initial architecture from that description.

From this, it generates a project-specific setup: agents, models, tools, MCPs, skills, permissions and routing.

And importantly, **the configuration isn’t frozen after initialization**.

As the project evolves, the system can re-evaluate its own setup and propose changes: adding or modifying agents, tools, skills, permissions or model routing as new needs appear.

So the agent system itself evolves with the codebase.

**2. Frontier models think. Smaller models execute.**

A frontier model acts as the **orchestrator**: it understands the request, plans, decomposes and dispatches the work — but doesn’t write the code itself.

Execution is handled by smaller models with focused responsibilities.

Every output then passes through deterministic gates — lint, types, tests, build — followed by an independent verifier.

If something fails, it goes back into the loop with new instructions. Complex cases can be escalated to a stronger Deep agent.

The idea is to spend expensive intelligence on **reasoning and decisions**, not on every token of execution.

**3. It learns — without letting context grow forever**

When something fails, the system can extract the cause and correction and reuse that lesson later.

If the same problem keeps appearing, the lesson can eventually become a **lint rule, regression test, hook or other safeguard**.

So instead of endlessly remembering *“don’t make this mistake again”*, the project eventually makes the mistake impossible.

We also built **intelligent context compaction**.

Context isn’t randomly summarized when the window fills up. Information is ranked by relevance and task state, important context can stay pinned, older validated context is compacted first, and everything compacted remains archived and recoverable.

So the goal is a system that improves not only its code, but also **its configuration, memory and context management over time**.

⸻

We’re seriously considering packaging this properly and releasing it as open source.

So I’m curious:

**Would you actually try this?**

Are you interested in experimenting with different agentic coding architectures, or are you already happy enough with Claude Code, Codex, Cursor or OpenCode that you wouldn’t bother?

If we released it, would you be interested in **testing it, breaking it, contributing to it, or integrating it into your own workflow?**

Trying to understand whether there’s real appetite for this before we take it further.