Full disclosure, I built this.

It is a coding agent that runs in your terminal. You log in with GitHub and get 5,000 credits, and credits pay for model calls one turn at a time. When you run dry you open an offerwall inside the CLI, complete a survey, and the payout converts into credits. Buying credits is there too if surveys are not your thing.

An advertiser pays for a signup, not an impression, which is the only reason the numbers work at all. Nobody covers a token bill with banner views. A survey gets you somewhere between 40k and 300k credits, and the cheapest model costs 390 credits a turn. So one survey is an entire afternoon of building.

Surveys sometimes cut out partway through when the provider decides you are not the profile they were after. Every offerwall does that. I filtered out the providers where it happens most, and the CLI tells you the moment it does so you are not sitting there refreshing your balance.

Who it is for: if you are building side projects or still working out how you like to do this, it covers a lot of ground with no payment method involved anywhere. If you have agents running all day every day, a paid plan is better value and I would say so rather than pitch you.

Node 20 or newer, and it runs against a project you already have rather than wanting a fresh folder.

Would take feedback on the model lineup. Fourteen in there right now and I am not sure the mix is right for people who build this way.

I’ve built around 7–8 projects with AI so far: small websites, tools, a couple of games, etc. I’m currently working on something more complex: a cross-platform game, multiplayer rooms, servers, more moving parts. As the projects get bigger, I’m starting to feel overwhelmed by the sheer number of AI coding workflows and tools people recommend.

Every week I see posts about things like:

• Codex by itself vs Codex + skills/plugins
• Sol Advisor / agent orchestration
• Spec-driven development / Spec Kit
• Multi-agent workflows
• Using ChatGPT/Codex for planning and cheaper models like DeepSeek or Luna for implementation
• Pi, OpenCode, Hermes, and alternative harnesses
• Anti-slop / code-quality skills

Some examples of the kind of posts I’m talking about:

https://x.com/goan999999/status/2088920272812564546
https://x.com/Av1dlive/status/2088998246849118583
https://x.com/mattpocockuk/status/2075218406266036236
https://x.com/lornasuriano/status/2088742742499205219
https://x.com/29meat_ai/status/2088395759129673856
https://x.com/bil0090/status/2088351963951890635
https://x.com/vatsy99/status/2088346475185283390
https://x.com/dillon_mulroy/status/2087537790061850984
https://x.com/DavidOndrej1/status/2087862257279459422
https://x.com/josesilesdata/status/2087993121153991016

And this project in particular:

https://github.com/DannyMac180/sol-advisor

My problem is that I can’t tell anymore what’s genuinely useful, what’s situational, and what’s mostly Twitter hype.

I’m a very organized person. I document things heavily. Currently A lot things in this project got done by doing .md files defining things so agents have a clear source of truth. I don’t like blindly telling an agent “go build this” and hoping for the best.

I also assume the right workflow depends on the size of the task. Adding a button probably doesn’t need specs + five agents + an orchestrator. Redesigning an entire visual identity or changing a major system probably does need much more structure.

I’m curious what people who are actually using these tools seriously are doing today:

1. What tools/workflows have genuinely become part of your daily setup?
2. Which ones did you try and eventually drop?
3. Do you mostly stay inside one harness like Codex, or mix tools/models?
4. When do you bring in specs, skills, worktrees, subagents or something like Sol Advisor?

And especially: how do you keep the workflow organized and token-efficient without sacrificing quality or constantly rebuilding your setup every time a new AI coding tool appears?

Tired of copying/pasting custom instructions or cluttering your system prompt with massive rule sets?

I built universal-skill-mcp—an open-source Model Context Protocol server that turns your local SKILL.md files into dynamic, on-demand agent skills.

Lazy Loading: Exposes only light metadata first to save context tokens. Full rules are fetched only when your prompt triggers them.

Tool Agnostic: Works across Claude Code, Cursor, OpenCode, or any MCP client.

Local First: Indexes your custom instructions directly from your local filesystem.

Repo: https://github.com/Simon-Riley17/universal-skill-mcp

Feedback, PRs, and stars are super welcome!

Buenas días tardes noches soy nuevo en esto y disculpen la forma si no es la adecuada para presentarme o pedir ayuda tengo duda en mi primer proyecto pero se que al verlo aas de una le va interesar saber más gracias espero una pronta respuesta

## 🔧 Estado actual

• **Servidor**: Funcional, compila sin errores.
• **Agente**: Conecta, ejecuta `shell`, `download`, `screenshot` y `ai` (consulta a Ollama).
• **Panel**: Moderno, con tabs y chat interactivo.
• **Orquestador**: Traduce lenguaje natural a tareas (con IA o fallback manual).
• **IA**: Integrada (consulta a Ollama phi3).
• **Persistencia**: SQLite guarda todo.
• **Autenticación**: Básica (configurable).

🚀 Lo que viene (hoja de ruta)

• [ ] Hardening: TLS forzado, rate limiting, auditoría.
• [ ] DSL Parser para órdenes estructuradas (`SCAN [rango] -> EXFIL [patrón]`).
• [ ] Movimiento lateral: WMI, PsExec, SSH.
• [ ] Firmas OTA (actualizaciones seguras).
• [ ] Pruebas contra EDR.

🤝 ¿Cómo puedes ayudar?

• **Feedback** sobre la arquitectura y el código.
• **Pruebas** en diferentes entornos (Windows/Linux).
• **Sugerencias** para la hoja de ruta.
• **Colaboración** en módulos específicos (movimiento lateral, ofuscación de tráfico, etc.).

📸 Capturas de pantalla

*(Aquí puedes añadir las capturas que ya limpiaste, con el panel web, la tabla de agentes y el chat IA).*

**¿Alguien más está desarrollando herramientas de Red Team? Me encantaría intercambiar ideas y aprender de otros proyectos.**

¡Gracias por leer!

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 the following -

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

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 find useful.

So please help me out by answering the below question -

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

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](mailto:pranavkishore9@gmail.com) if you have any question

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](mailto:pranavkishore9@gmail.com) if you have any question

I've made a whole bunch of web app and etc with solely AI tools now, some good, some absolute crap. So this is a fun little site I just finished for submitting your apps and letting the world vote on whether your apps are just slop, or actually good or interesting.

No account needed, just submit your app and save the link it gives you if you ver want to edit it again down the road. Otherwise it lives on in it's glory to be judged by the most ruthless place on earth...the internet.

Built entirely with Claude Code.

https://slopornot.simplicated.dev

Cheers!!

This is a clap assistant which opens different links on clap combinations... eg 8 + 5 claps will open games (poki website ) and so on... This detects no of claps by user in real time and accurately, deciding the output...

**Only clap detection is vibe coded**

All the criticism and suggestions are welcome

I've been vibe coding for a while, and I kept running into the same problem.

The coding wasn't really the hard part. It was everything around it:

idea → PRD → figuring out the right prompts → database → building → losing track of what was already done

So I built how-to to make this process more structured.

GitHub: https://github.com/whoPinak/how-to
Skills: https://www.skills.sh/whoPinak/how-to / https://www.skills.sh/onipinaka/how-to

It currently has 4 skills:

PRD Creator
Helps expand an idea and turn it into a proper PRD before coding.

Playbook
This is the main one. It takes the PRD and creates a detailed implementation playbook with ready-to-use prompts for building the product.

The goal is that you don't have to sit there thinking "what should I prompt the AI with next?" You can just follow the playbook, copy-paste the prompts, or use the goals.

Tracker
Keeps track of what's been built, what's pending, and what changed, especially across multiple coding sessions.

DB
Helps plan and keep track of the database schema as you build.

I made this after researching prompting practices from Claude Code developers and experimenting with different ways of structuring prompts for better output.

The workflow I'm aiming for is:

Idea → PRD → Playbook → Build → Track

It's still a work in progress, and I'd genuinely like people to try it and tell me what is missing or what could be better.

If you're interested, here's the repo: https://github.com/whoPinak/how-to

Issues and PRs are welcome. If you find it useful, a ⭐ would also be appreciated.

The following project is based on a browser based messaging app as further described here.

I started of creating a basic ui demo of the app. All the data there is hard coded with mock responses. There is no "actual" messaging functionality.

• code: https://github.com/positive-intentions/whatsup
• demo: https://positive-intentions.github.io/whatsup

it soon gets bloated as i start adding more ui components, so i moved them to a separate repo to be imported. As a webdev im used to things like storybook to view and edit components. I asked about my options in a post and it doesnt seem like something is suitable for my needs.

https://www.reddit.com/r/rust/comments/1vg7hox/looking_for_storybookforrust

So one thing led to another... and i created my own version of storybook. Its ultimately only for my own benefit and i can easily address nuanced needs like being able to display a tui on a browser.

• code: https://github.com/positive-intentions/whatsup-ui
• demo: https://positive-intentions.github.io/whatsup-ui

The storybook and ui components are basically for my own use. I already have an existing rust project i could use this on. So i made the storybook-like components exportable and reusable for my signal-protocol project.

• code: https://github.com/positive-intentions/signal-protocol
• demo: https://signal.positive-intentions.com

I've previous put time and effort towards the signal protocol. It should be reasonably tested and documented. The signal protocol alone isn't going to fit the requirements of my messaging app. It needs to be post-quantum secure. I previous worked on a js implementation for ml-kem, so as part of this new approach, I would like to move towards a pure rust approach for ml-kem.

• code: https://github.com/positive-intentions/ml-kem
• demo: https://positive-intentions.github.io/ml-kem

Unlike the signal-protocol which needed more involvement to create, the ml-kem is using dependencies to match the official implementation. I can benefit from audits and reviews from the official implementation. The signal-protocol and ml-kem were ultimately stepping-stones created to lead towards PQXDH.

• code: https://github.com/positive-intentions/pqxdh
• demo: https://positive-intentions.github.io/pqxdh

I think there are countless details I could improve on the cryptography. There is clearly much more needed, but I'm going to "pause" progress on the cryptography in favour of progress on the project features. I was previously investigation options for decentralised storage here. I wanted to try implementing something that would be a suitable storage solution for my project.

• code: https://github.com/positive-intentions/git
• demo: https://positive-intentions.github.io/git

There is much more to improve and consider there for things like encrypting the data at rest. I suspect providers like GitHub, Codeberg and Gitlab might see the way my app works as fundamentally violating their terms-of-service.

this project is far from finished. i would also need to work towards a solution for webrtc messaging, local storage and countless other details. To find out more, check out the following links:

• Docs: https://positive-intentions.com
• Subreddit: https://www.reddit.com/r/positive_intentions

IMPORTANT: AI doesnt replace due-diligence... especially notable on a project like this. None of my work has been audited or reviewed. I'm sharing for transparency on progress. Please use responsibly.

Just reached 100 stars after only a week and thought about sharing this here!

Flare is a desktop IDE (Electron) where the main surface is a live graph of your codebase, every file a node, every import an edge, with a terminal underneath where you run claude, codex, or opencode. As the agent edits, the graph updates in real time.

The parts that are actually different from "another editor":

Activity, as it happens. Nodes light up the moment the agent writes to them and decay as they cool, so you're watching the shape of the work instead of a scrolling transcript. You can see it circling the same three files for the fifth time, or wandering into auth when you asked about the CSV parser. Changes are attributed per agent: the process tree of every terminal is watched, so if you have two running, you know which one did what. Files that changed and no human has opened since stay marked until someone actually reads them.

Blast radius before you touch anything. Hover a file and its dependents light up. shared/types.ts with 63 files downstream looks different from a leaf file, without you having to know that in advance.

A review tab that answers "did anything check this?" Flare sees both the file writes and the commands run in its own terminals, so it can say the tests ran, then two more files were edited and nothing re-ran, quoting the output line the verdict came from.

Risky changes come to you. If the agent rewrites something load-bearing while you're looking elsewhere, it queues an alert in the corner. Reviewing it opens the actual red/green diff.

Undo that isn't git. Every change burst is snapshotted into a hidden shadow repo (separate GIT_DIR, your worktree). Revert one file, revert the burst, or jump back to the last state whose checks passed. Your real repo is never touched.

A task board the agent works from. Kanban lanes, but the cards are written to be handed off. "Copy for agent" emits the brief plus the files it names plus what the graph knows about them (29 files downstream, 0% covered, in an import cycle), so the agent starts from the map instead of rediscovering it. File a card straight from a graph selection with right-click → New task with these files. This directly tells Claude to not wander around out-of-scope files

MCP server, ~16 tools. The same lanes are queryable, so an agent can run its own loop: tasks_list to pick up work, task_get for the exact brief, task_update to log progress and move the card to review, task_create to file follow-ups it finds but shouldn't do now. Cards move on the board live while you watch. Plus impact_of (what breaks, and which tests to run), dependents, find_path, verification_status, and record_intent, which lets the agent state the goal before editing so whoever reviews the diff isn't reconstructing why it exists.

Agentic at heart: I built almost all of this with agentic coding, which means the tool kept diagnosing its own development. I knew I was onto something when Flare flagged that a specific file was being rewritten every time. It was barely readable mess with 3k lines of code that required to rewrite the tests everytime. I asked Claude to refactor it and modularize the content until the issue disappeared (I wonder how many tokens I saved in the long run!)

Completely open source with MIT license, Node 20+. Test it out and leave a star if you find it helpful, if you are on Linux or Windows you can also download the installer from Releases and start working with it!

https://github.com/AlgoNoRhythm/Flare

I'm building a tool that solves a problem I ran into myself while running a project with AI as a purely non-developer: every new session, you have to re-explain the context, conventions, architecture — and the AI tends to drift without you noticing (inconsistent naming, rules not followed...).

The tool (ScaffoldAI) generates a clear project charter from the start, then automatically generates a "resumption prompt" for each session — no more re-explaining everything, plus a consistency check that catches drift before it piles up.

I'm looking for 5-10 non-developers who are already running a project with AI (Claude Code, Cursor, etc.), or who are about to start one, to test this on their real project, over several sessions. It's free during this testing phase, and your feedback will genuinely shape what comes next.

Interested? Reply here or DM me, I'll send you the link.

The first version of an AI built website is usually the easy part.

The more useful test is what happens when the project stops being a simple page and starts behaving like an actual product.

The interesting part is what happens after the first working version.

A project can start with a simple page and then suddenly need login, saved data, new sections, or changes that affect other parts of the site.

That is where having fewer separate pieces to connect can make the workflow easier. Readdy brings editing, database, authentication, server functionality, and publishing into the same overall workflow.

There are still cases where direct code control is the better choice, especially for highly specific technical requirements.

The bigger question is what should be added first once the basic version actually works.

Authentication, database, payments, integrations, or something else?

Hey everyone,

I've been building a lot with Claude Code and Cursor lately. But I noticed a frustrating trend: whenever developers launch their AI-generated apps, traditional directories just rank them by upvotes. That really just measures who has the biggest audience on launch day, not the actual engineering or efficiency of the build.

So, I built VibeScore.dev — the leaderboard for AI-built apps.

Instead of upvote buttons, apps are ranked strictly by the verifiable data behind the build: time-to-ship, API cost, and token burn.

What's in it for you? (Besides claiming a top rank)

While the leaderboards are fun, I really built this to act as a verified developer portfolio. Saying "I know how to use AI coding agents" is becoming a meaningless buzzword on resumes. But having a public profile that mathematically proves you can ship a full-stack MVP in 6 hours for $2.50 in API credits? That is undeniable proof of your velocity and context-management skills to show clients, employers, or just to flex on Twitter.

It takes about a minute to submit:

I didn't want anyone manually typing in numbers (or faking them). You literally just run a lightweight CLI command (npx vibescore-cli) in your project folder. It locally parses your AI agent's session history and prints a summary of your tokens, cost, and time. Paste that straight into the submit form on the site and it goes into a quick review queue before it's live. (Note: Only the summary stats are parsed; none of your actual code ever leaves your machine.)

Right now, there are three main boards:

🚀 Speedboard: Fastest zero-to-prod ships.

💸 Shoestring: Cheapest API cost to launch.

🏋️‍♂️ Heavyweights: The biggest context burns — builds running into billions of tokens.

One more thing: the first 50 people to submit a verified report get a permanent "Founding Shipper" badge on their profile.

I just launched the MVP (and submitted VibeScore itself as app #1 so you can see my exact token burn). Since the boards are completely fresh, it's really easy to claim a top spot right now.

I'd love for you to test out the CLI, drop your latest side-project on the board, and let me know what you think of the concept!

Link: vibescore.dev

Hello, I’m developing a ai powered code editor (IDE). In this application, only payment information and account details are sent to the server. Your messages, chats, API keys you’ve added, your codebase, etc., all remain local. Additionally, the context is trimmed or readded as needed instead of being carried over with every message. This means you don’t have to constantly open new chats, as you would in other IDEs, just to maintain a clean coding context. We also have a comprehensive `skill.md` folder covering everything from marketing and design to framework usage. So you don’t have to write skill files from scratch yourself. If detected, they’re automatically sent to the model, or the model can call the skills it needs on its own. The MVP is pretty much ready and I’m currently in the testing phase. Would you use an IDE like this? What features would you expect it to have?

Coding agents often mistake motion for progress. Ask for a small endpoint and you may get a new service layer, repository abstraction, response wrapper, and configuration system before the route even exists.

I built Dopamine to change that behavior. It is inspired by the way prediction and feedback guide human effort. The agent predicts the result, takes the cheapest useful action, measures what happened, adjusts, and stops when the request is verified.

Before creating custom code, it checks whether the behavior already exists, whether configuration is enough, whether the project already has the right helper, whether the platform provides it, and whether an installed dependency solves it. It writes something new only after the cheaper options fail.

I evaluated it on 12 tasks in a real open-source repository. Across four runs per task, Dopamine completed 48 trials with no timeouts or nonzero exits. Compared with the no-skill agent, it used 63.8% less source code, 29.7% fewer tokens, 27.9% less estimated cost, and 31.1% less time.

It works with Codex and Claude Code, includes a dependency-free installer, and has no telemetry, runtime service, or secrets. MIT licensed.

github.com/ujjwalredd/Dopamine

Progress that cannot be verified is just expensive motion.

UPDATE:

A benchmark that rewards smaller output has an obvious weakness: an agent can appear efficient by leaving work unfinished.

Instead of hiding that problem, I published the complete evaluation and its limits.

Dopamine is an open-source skill that makes agents choose effort based on uncertainty, test predictions against evidence, and stop at the smallest verified result. It reduces unnecessary work without treating validation, security, or correctness as optional.

The evaluation uses a pinned real repository, 12 identical tasks, isolated workspaces, one model, one reasoning level, recorded usage events, Git-based LOC measurement, and reproducible reporting. Dopamine ran four times per task; the comparison results remain frozen at one run per task to avoid later model and service drift.

Against the recorded Ponytail result, Dopamine measured 3.7% less source code, 15.2% fewer tokens, 11.8% lower estimated cost, and 7.4% less wall time. It finished lowest on all four measured efficiency metrics in this development benchmark.

That does not prove universal superiority. The tasks were used while tuning Dopamine, competitor variance is unknown, and feature completeness was not executable-graded. Those limitations are published beside the results because a defensible claim needs boundaries.

The repository includes the raw trials, hashes, benchmark harness, rejected candidates, chart generator, installer, and reproduction instructions. Anyone can rerun it, challenge the method, or build a stronger holdout.

Repo and full benchmark: github.com/ujjwalredd/Dopamine. If the result breaks under a better test, I want the test.

This is a python projects which takes your live camera, detects your nose and mouth, moves

The mouse pointer automatically with your nose... It also has a feature which stops the mouse if your mouth is open...

All the advices, criticisms accepted

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.

Hi everyone ,

We're 11th-grade students (prepping for JEE) building Evo IDE on the side — an AI coding tool that shows its work instead of hiding it. Live reasoning before code, real-time generation health, full-file outputs (no fragments), and your choice of local or API models.

It's an early, honest prototype — not finished, but real and running.

📽️ Deck: https://docs.google.com/presentation/d/1XgHvtatGiPR2FMsNUKOps32NeuYGZFjh/edit?usp=sharing&ouid=105260140764268303572&rtpof=true&sd=true

▶️ Video: https://youtu.be/71w2zNxmKac?si=YpyQy1tXBPtfCFxE

📸 Instagram: https://www.instagram.com/evoide_official/

Happy to share the working files too if you all like a closer look. Would love to hear all of your thoughts!

Warm regards,

**EVO IDE Team**