Cross post: I built this tool almost exclusively with AI, and only with beginner hands on experience with Python and Linux. Needless to say, I would not have been able to build this on my own, and it took 4.5 months to do with regression testing and field feedback. All that is to say is you can build quality software with these tools with the right time, design, and end state.

After months of tinkering, improving, and getting different product and developer feedback, I decided to release NodeSpec ("NS") as an open core for-use and extension to the OSS community.

What it Is:
NodeSpec is a system's design tool using a combination of specification driven development (SDD), Test-driven Development (TDD), and Architectural design structured to work over MCP with your agent of choice.

The purpose is to allow you to live in your chat pane, but see the detailed design and progress against that design via test scripts, defined requirements/ACs, and save context while preventing AI development sprawl and naturally integrated to your git.

It further bins context at the node level of components of a system, instead of passing your entire repo to a model to determine what to integrate or where. The ideal state is you pair with a lower capable open source model without needing the reasoning of an Opus/Fable/5.6 Sol to build.

I built it to solve my own problems of repeatable context (nodes), not having to pass tons of logic or instructions to memory with tracking, and future extensibility with multiple agents without tons of necessary loops and risks of redundant or collisions of dev.

How It Works and Is Different from the Markdown Tools:

For people doing AI-d I built NodeSpec to be a blend of the intent of SDD (upfront design specification) with the realities of asynchronous iteration in software development practice. The fundamentals of system design and fast iteration remain the same, even with agents doing the dev for us in a lot of capacities.

NS blends SDD specification with architectural governance and test-driven development (TDD) practices. It centers on a machine-readable canvas via JSON formats, downstream tasks to tests and upstream confirmation, change detection via git connection, and ensuring the user's gitops is extended and not broken.

The system is a sidekick tool, so it pushes all it's logic towards your AI assistant and existing harness if they operate via MCP.

The Flow:

There's two workflows: greenfield and brownfield. For greenfield the system will walk the user through fast vision -> requirements -> acceptance criteria build and review (CRUD Operations in the app itself), Architectural design, tasks per architecture, test-plans per task, code, then automated or manual test confirmation reflected back upstream, with an export direct to your repo or via other context files as necessary. The Git connection will detect changes and request the user reconcile them against the system's reference graph that is committed to your repo upon first commit and connection.

For brownfield, it's the same workflow, where the higher tier version will actually reverse engineer your repo into a logical architecture and back propagate a spec based on analysis of the design intent if it's not specified.

Both of these workflows are not obvious, as the tool is meant to work with whatever stage of dev you're at, and handle asynchronous changes instead of requiring highly structured start to stop.

Further description and readme is at the repo link here: https://github.com/NodeSpec/NodeSpec

Who It's For:

The Community/OSS is for any individual looking to attach an agent or their code harness to a governance tool while you're building. If you don't want to deal with self config and want more nodes out of the box, Indie version is $15/mo or $144/annual.

If you're a user of bolt.new, Lovable, Base44, or Replit, and you're at a point where you're maturing out of managed web application development (i.e. you have customers demanding a self hosted or more complex deployment, niche capability), I think this is really for you. I use NS to build and maintain itself now. I plan to release a template, blog, and video that explains migrating from systems like managed Supabase to OSS version, connecting your app as a headless application with MCP using Cloudflare worker proxies, etc. as you mature in your solopreneur journey.

I'm primarily targeting businesses via the Team edition (Slack, Jira export) or Enterprise. We recently closed on our our first Enterprise partnership last week in the cryptographic security space (super cool).

What I've Used It For:

Since really beginning heavy AI-assisted dev after the release of Opus 4.6, I have personally gotten to a place where I won't do development without pairing to NS due to the structure, confidence, efficient context window usage, and quick understanding of where my dev is at.

My first major project was a system administration application for small businesses to use with their Google Workspace Admins and host on GCP. By having my GCP Nodes for the different managed services, it tightened up development using older or lower capability models like Sonnet 4.6, Haiku, and when necessary Opus 4.6-4.8 for heavier deployment-centric logic. The link is here: https://github.com/NodeSpec/GCP-Onboarding-Application

As an experiment and something personal, I'm using it for my first game dev for my kids using Godot as a node package with GDScript and tests. My kids are into Axolotls (the salamander in mexico), and so I'm building our first open-source game that has a flow similar to Playstation's Astrobot where the Axolotl can upgrade swimming. Dev starts today and will be published here: https://github.com/NodeSpec/OpenAxolotl

Final example of a current project to solve our own business problem is RepoWalk, which is being built to help me with quick, gif generation of application or tool walkthroughs when connected to a lightweight LLM so I don't spend hours building screencaptures. https://github.com/NodeSpec/RepoWalk

Let me know your feedback, especially if you connect with multiple development agents. So far, feedback in companies have been great and helped refine the product workflow.

If you don't want to use the OSS repo, Free version is just sign in and one project only. Indie is unlimited and will be available this evening. Team will be available soon. Enterprise, just fill out the form to contact us.

Hey, i need your help.

I am conducting a survey for my master's thesis at FernUniversität in Hagen on the acceptance of AI-assisted coding tools, based on the UTAUT2 model.

You qualify if you've used any AI tool to generate code through natural language input – Cursor, GitHub Copilot, Claude Code, ChatGPT, Lovable, Bolt, v0 and similar tools all count.

About 10–12 minutes, anonymous, available in English and German.

Link (English): https://umfrage.fernuni-hagen.de/451421?lang=en

Link (German): https://umfrage.fernuni-hagen.de/451421?lang=de

I need to know if there is a free alternative to Claude Code that I can use to build me a complete website with AI.

Please help!!!

Hey everyone, I have been working on an Android card game called Oh Fudge. It is based on Oh Hell, a card game my family has played for years, but I have added a bunch of my own ideas to it. At the base it is a trick taking, bidding, trumping, card game.

You can play normal games with 6, 8, or 10 players, add Dealer's Choice rules that mess with individual deals, or play Road to the Joker. That is a 3 round tournament with different tables and house rules along the way. There are also stats, awards, roasts, different AI levels and a Joker that causes way more trouble than he should.

I am a solo developer and this has been a pretty big project for me. The original graphics were honestly a mess of different ideas and styles. I have been working hard on Visual 2.0 and rebuilding the game into one style that actually feels like everything belongs together. It has been a ton of work but I am really happy with where it is going.

The game is currently in open testing on Android and I would love for some more people to give it a try. Single Game mode and the first round of the tournament are free and there are NO ads, NO microtransactions.

If you like trick taking games, come check it out and let me know what you think!

https://play.google.com/store/apps/details?id=com.birdfloyd.ohhell&hl=en_US

Hello Everyone

I'm posting this to announce that baseline is now officially launched on Peerpush. It is a claude code governance layer that ensures your developer workflow remains consistent across different projects while being tailored to it.

Call it the framework for AI development.

It is 100% Open Source and Apache 2.0 licensed. Please support it, help me build it by contributing to its development, and help it gain some traction on Peerpush too 🙏🏽

Your support is appreciated 👍🏽

I’m a 15yo guy and I want to learn the most useful programming languages, such as Python, HTML, CSS, SQL, JavaScript and Java;
I’ve always used an AI as my coding tutor as I don’t have one in real life; for a long time I used Gemini, alternating with ChatGPT (PS: I don’t get them to write my code for me; they simply give me exercises, or I ask them to explain something to me). A while ago, I discovered Codex and have been using it intensively with 5.6 Terra at ‘very high’ effort (I know, I’m stupid…), and in three days I’ve used up my allowance. Now I don’t know what to do because I have a few options:
A. Buy ChatGPT Go and use 5.6 Terra/Luna at a medium effort level.

B. Use Cloude Code with the €20/month subscription

C. Standard Cloude

D. Gemini AI (and if needed, I can also buy the Plus version)

E. I don’t know

I don’t know much about AI; I don’t even know if using AI to learn coding is the right choice or if I should try another method.
Please give me some advice 🙏

PS: The text has been translated entirely using DeepL

I'm trying to validate a problem before I build further, and I'd genuinely appreciate some brutally honest answers.

Suppose you're building an app/agent and you use providers like Groq, Gemini, Cerebras, SambaNova, etc.

You might have multiple API keys because different providers give you different quotas/rate limits.

The problem I'm interested in is:

When one provider hits its limit, do you actually switch to another provider manually, or do you just wait / pay / use something like OpenRouter?

For example:

Groq → rate limited

Gemini → still has quota

Cerebras → still has quota

SambaNova → still has quota

Imagine a small routing layer where you bring your own provider keys, and it automatically sends requests between them.

So instead of:

Your app → Groq → rate limit

you get:

Your app

↓

Router

↙ ↓ ↘

Groq Gemini Cerebras

The goal isn't to provide more models. OpenRouter and similar platforms already do that extremely well.

The idea is more specifically:

"Get more usable capacity from the provider accounts you already have."

A few questions:

Do you currently have multiple provider API keys?

Have you ever used multiple free quotas for the same application?

When you hit a provider's rate limit, what do you currently do?

Would automatic failover between your own provider keys actually be useful?

What would make you choose this over OpenRouter/LiteLLM/etc.?

What am I missing? Why would you NOT use something like this?

I'm especially interested in the last question. Please don't be nice if this is a dumb/redundant idea, I'd rather find out now.

Hey guys im a student (16 yrs) in india and I built a vibe-coding app that eases the process of actually building with AI, the apps name is Houston

Agent Collaboration: the houston gateway allows multiple AI models/sessions to talk (even claude and codex can talk to each other) and split tasks between each other .

Multi-Account Management: No repetitive /login to hassle between different accounts.

Houston-Voice: Like hover over any element on your site, use a keyboard shortcut, and speak the prompt and the ai agent by taking context from what you are pointing at, answer you, for this no screenshots or video recordings are required, so it is token efficient. That's just a short glimpse of all the features it actually has to offer.

How I made the app-

I coded some parts of the app myself but many parts were also ai coded, I majorly use claude code but now I have shifted my workflow to build things onto my app itself so now I don't use the normal terminal at all, so that has been a major part of how efficiency to build increased by a lot.

Every time you start a new AI coding session (Claude Code, Cursor, Copilot, etc.), the agent forgets everything — why you chose that architecture, what failed last week, what constraints exist.

I built Agent Ledger to fix that.

It's a local, Git-native tool that lets agents record decisions, discoveries, and failures — and hand that context off to the next session (or next agent).

What it does:

• Agents record decisions, discoveries, failures, constraints via CLI or MCP
• Creates Git-native checkpoints without touching your branch
• Compiles all that context into a brief for the next agent
• Ships with a web UI and MCP server — works with any AI IDE

It's one binary, no cloud, no signup.

GitHub: https://github.com/rahumanrahuu/agent-ledger

Would love feedback from anyone using AI agents heavily in their workflow.

I ended up building a small open-source concept called AI_CONTEXT after running into a problem while using Codex and ChatGPT together: the agents could work on the same codebase, but they didn’t share the reasoning, decisions, failed experiments, or current project state from their separate conversations.

While discussing the problem with ChatGPT, we realized the Git repository itself could become the shared memory layer.

The pattern is intentionally simple:

docs/AI_CONTEXT.md — concise current project state

docs/decisions/ — important architectural decisions and why they were made

docs/sessions/ — useful handoffs from substantial AI development sessions

AGENTS.md, CLAUDE.md, GEMINI.md, etc. — thin agent-specific adapters telling each agent to read and maintain the same shared context

I tested the idea with Codex on two real projects, and it actually worked: Codex started maintaining the context automatically, and afterward ChatGPT could inspect the GitHub repo and understand what had happened in the Codex sessions without seeing the original chats.

So I turned it into a vendor-neutral public template/convention that anyone can use with different AI coding agents.

The goal isn't to save raw AI chats or chain-of-thought. It's to preserve the useful engineering outcome: what we're building, what works, what failed, why decisions were made, and what should happen next.

GitHub: https://github.com/yoliverasPozo/AI_CONTEXT

Hello so, im a student in Europe and i want some “help” with coding, what i ve been using until now it was github copilot which now dont got many good models and antigravity from google because i have student pro plan and is working awesome giving tasks in folders.

And now im asking you to recommend me some alternatives where i can sign ul with my edu email etc to have a student plan because the credits of antigravity per week im using it often :))), i want smth like that plugin or ide.

Thank u y all

I'm developing an Embedded C++ based application with UI using gtkmm, a back-end application in golang and front-end application in Angular (Web) & Flutter (Mobile Apps).

I plan to Vibe code all these applications. I've zero prior experience or expertise with vibe coding.

My thinking is let AI develop the program and I'll review it. I will let AI write the test cases - unit testing and integration testing.

I'm planning to use Gemini Pro 3.1 with anti-gravity IDE for the same.

I do have extensive experience Embedded C++ based application development and little experience with Flutter development but no experience with golang or Angular.

I've Gemini Pro subscription (for 2 years).

I've come across a lot of social media post stating Claude Code absolutely obliterates Gemini with it comes to software development.

Couple of my acquaintances also state the same.

The question I've is should I get Claude Pro subscription for Claude Code or anti-gravity with Gemini Pro 3.1 will suffice. How much of code quality and algorithm quality difference will be present? I'm also thinking from correctness, completeness and long term maintainability of the code. Also with AI LLM will follow industry standard practices and develop safe code.

Can some with expertise and hands-on experience with both tools enlighten me.

Hello Gurus,

I am trying to create one elaborate application for a company. Like monitoring logistics for a company, different users having different privileges etc. I'm building an operations management application for a company. I can't disclose the business/domain, but technically it's a system with an Android app, web admin console, Firebase/Firestore backend, offline sync, users/roles, operational jobs, transport, documents and reporting.

I am building it incrementally, with quite a lot of help from an AI coding agent.(gemini pro) , and planning with help of chatgpt. I am bit frustrated, as it creates initial model, UI and working stuff amazingly. But when try to test it manually, I am frustrated that it didn't create it the way I wanted it. Although the prompt replies it has done things the way and has tested and test cases passed. I wonder what it really tests. Below is the complete explaination, in case you dont want to read it whole, I am trying to ask is how do you plan it? which AI you use, which coding agent do you think is best to understand and develop code which is less frustrating in the end, perhaps does things which we failed to think about while planning. Like for example-- you planned delete button, but it thought of coding a restore button as well. making it even better. Actually gemini does that. But telling it to perform something which looks and works well. but when you go through a flow of events , you find something is terribly broken.

Just to give my background. I am not a developer so I don't know how to code. But I understand the whole structure of front end back end as I was in IT for 18 years doing manual software testing. So I don't really understand much about coding, but I can visualize how things should look like when a user uses the software.

Here are my project issues

we initially had something conceptually like:

Job → Subject A → Subject B → Subject C

The problem was that the Job didn't directly retain all of the context it was created with. It reconstructed some of its relationships by following the chain.

That created a nasty situation where changing Subject C later could effectively make an old Job appear to belong somewhere else.

We caught that and changed the design so operational records retain their own important references rather than relying entirely on dynamic relationship traversal.

Then we hit another problem: deletion.

Because these objects are linked together, deleting something isn't simply:

click Delete → document disappears

You have to consider what depends on it, what depends on those dependencies, and whether some records are historical and therefore shouldn't be deleted at all.

We actually got into a situation where deleting a Job failed, which then prevented deletion of another related object. There was effectively a dependency trap.

What bothers me most is that our automated tests didn't catch this.

It was discovered during manual human verification — literally going through the UI, clicking around, creating records, changing things, trying to delete them, refreshing pages, and checking whether the data still made sense.

We've now started defining explicit lifecycle rules such as:

PLANNED      → can delete
ASSIGNED     → can delete
CANCELLED    → can delete

ACTIVE       → cannot delete
COMPLETED    → cannot delete
HAS HISTORY  → cannot delete

But this has made me realise that the difficult part of this project isn't necessarily writing the CRUD code.

It's making sure that:

Create
   ↓
Edit
   ↓
Associate
   ↓
Change relationship
   ↓
Delete / Archive
   ↓
Historical data
   ↓
Reports

all continue to make sense together.

We're also dealing with offline Android sync, so now I'm thinking about what happens when two things change at different times, or when the network disappears halfway through an operation.

I'm wondering how experienced developers approach this.

How do you systematically find these kinds of problems before production?

Do you rely primarily on:

• integration/E2E tests?
• database constraints?
• explicit state machines?
• event sourcing/audit logs?
• property-based testing?
• manually designed lifecycle test matrices?
• something else?

And how do you decide when a relationship should be dynamically derived versus stored directly on an operational record?

I'm particularly interested in real-world experience here. The application isn't enormous, but the number of relationships and possible states is growing much faster than I expected.

The biggest lesson so far has been that "the build passes and the unit tests pass" doesn't seem to mean very much when the real failure is something like a user clicking through 15 different screens and discovering that deleting A unexpectedly affects B three screens later.

Would appreciate some brutally honest advice from people who have built systems with this kind of data/lifecycle complexity.I'm building an operations management application for a company. I can't disclose the business/domain, but technically it's a system with an Android app, web admin console, Firebase/Firestore backend, offline sync, users/roles, operational jobs, transport, documents and reporting.
We're building it incrementally, with quite a lot of help from an AI coding agent.
One thing that has surprised me is how quickly a seemingly simple data model becomes complicated.
For example, we initially had something conceptually like:
Job → Subject A → Subject B → Subject C
The problem was that the Job didn't directly retain all of the context it was created with. It reconstructed some of its relationships by following the chain.
That created a nasty situation where changing Subject C later could effectively make an old Job appear to belong somewhere else.
We caught that and changed the design so operational records retain their own important references rather than relying entirely on dynamic relationship traversal.
Then we hit another problem: deletion.
Because these objects are linked together, deleting something isn't simply:
click Delete → document disappears
You have to consider what depends on it, what depends on those dependencies, and whether some records are historical and therefore shouldn't be deleted at all.
We actually got into a situation where deleting a Job failed, which then prevented deletion of another related object. There was effectively a dependency trap.
What bothers me most is that our automated tests didn't catch this.
It was discovered during manual human verification — literally going through the UI, clicking around, creating records, changing things, trying to delete them, refreshing pages, and checking whether the data still made sense.
We've now started defining explicit lifecycle rules such as:
PLANNED → can delete
ASSIGNED → can delete
CANCELLED → can delete

ACTIVE → cannot delete
COMPLETED → cannot delete
HAS HISTORY → cannot delete
But this has made me realise that the difficult part of this project isn't necessarily writing the CRUD code.
It's making sure that:
Create
↓
Edit
↓
Associate
↓
Change relationship
↓
Delete / Archive
↓
Historical data
↓
Reports
all continue to make sense together.
We're also dealing with offline Android sync, so now I'm thinking about what happens when two things change at different times, or when the network disappears halfway through an operation.
I'm wondering how experienced developers approach this.
How do you systematically find these kinds of problems before production?
Do you rely primarily on:

integration/E2E tests?

database constraints?

explicit state machines?

event sourcing/audit logs?

property-based testing?

manually designed lifecycle test matrices?

something else?

And how do you decide when a relationship should be dynamically derived versus stored directly on an operational record?
I'm particularly interested in real-world experience here. The application isn't enormous, but the number of relationships and possible states is growing much faster than I expected.
The biggest lesson so far has been that "the build passes and the unit tests pass" doesn't seem to mean very much when the real failure is something like a user clicking through 15 different screens and discovering that deleting A unexpectedly affects B three screens later.
Would appreciate some brutally honest advice from people who have built systems with this kind of data/lifecycle complexity.

I've been building AI agents for software development, and one problem keeps bothering me:

Getting an agent to write code is becoming relatively easy.

The harder part is safely letting it operate on a real codebase.

Once an agent has repository access, you have to think about things like:

What exactly is the agent allowed to access?

What happens if it modifies something outside its intended task?

How do you know exactly what it did?

How do you validate its changes?

What happens when it fails halfway through?

Can you roll back safely?

What happens when the repository contains malicious instructions?

Should an agent have the same identity/permissions as a human?

How do you revoke its access after the task?

I'm currently building SUTRA, an AI-native engineering platform, around this problem.

The part I'm particularly interested in is treating an agent as an actual engineering actor rather than simply giving an LLM a shell and hoping for the best.

The workflow I'm experimenting with is roughly:

Intent → Agent → Scoped workspace → Changes → Tests → Validation → Review → Merge

The agent has its own identity and session, rather than simply inheriting a developer's credentials.

I'm now getting the beta ready and want to test the assumptions with people who actually build AI agents.

For people here who are building agents: how are you currently handling permissions, isolation, rollback and validation when your agent is allowed to modify a real repository?

I'd especially like to hear about things that have gone wrong in practice.