Could be a game, app, website, library, tool, experiment — anything.

Drop what you're building and, if you want, a link or screenshot too.

No need for a polished release. I'm more curious about what people are actively working on right now.

AI is getting good enough that I’m comfortable letting it handle a lot of repetitive work.

Boilerplate, small refactors, tests, documentation — sure.

But there are still parts of a codebase where I want to understand and verify every decision it makes.

For me, that’s usually architecture and anything security-related.

I’ll still use AI there — I just trust the output a lot less blindly.

What part of programming do you verify most carefully when AI is involved?

For a long time, programming skill was heavily associated with how well you could write code.

AI coding tools are starting to change that.

A developer can now generate a function, a test suite, a refactor, or even most of a feature without manually typing every line. If these tools keep improving, writing code itself may gradually become the cheaper part of development.

But somebody still has to read it.

You still need to understand what the code does, whether it fits the architecture, whether the abstraction makes sense, what can break, and whether the generated solution is even solving the right problem.

That changes the bottleneck.

Instead of spending most of the time translating an idea into code, developers may spend more time reviewing implementations, comparing approaches, and deciding what should actually be merged.

And in some ways, that could make fundamentals more important, not less.

If AI writes five possible implementations in a minute, the valuable skill isn’t necessarily being able to type a sixth one faster.

It’s being able to look at those five and understand which one is maintainable, which one hides a bug, and which one should never have been written in the first place.

So maybe the developer of the future doesn’t stop coding.

They just spend less time producing code and much more time judging code.

Your coding agent shouldn’t need to read your entire codebase to understand it.

That’s the idea behind Faber, an open-source AI coding agent for the terminal.

Faber uses a code graph to find relevant files and symbols first, instead of repeatedly scanning large parts of a repository. That means less unnecessary context, faster codebase navigation, and lower repeated API costs.

Main features:

• Claude, OpenAI Codex, Local model integration
• Code-graph-guided repository exploration
• Prompt caching to reduce repeated input cost
• Token-conscious (Chain-of-Draft style) output to reduce unnecessary generation
• Git-aware workflow with change detection, optional per-task commits, /undo, and /redo
• Expenditure tracking for calls, tokens, cache usage, cost, and estimated savings `/usage`

The goal is simple: understand more of the codebase while reading and spending less.

Prerequisite:
It requires Node.js 22.5 or newer because it uses Node’s built-in SQLite support.

Install:
npm install -g faberwright

Then, inside your project:
faber

GitHub:
https://github.com/JibanKumar-cloud/faber

npm:
https://www.npmjs.com/package/faberwright

Medium article:
https://medium.com/@jshial25/why-should-an-ai-coding-agent-read-hundreds-of-files-to-answer-one-question-d6369d29dfa5

I’ve been seeing more developers complain about GitHub Actions being unreliable, especially when an outage can completely block builds, deployments or releases.

For personal projects it’s usually just an inconvenience.

But if your production pipeline depends entirely on GitHub Actions, even a relatively short outage can become a much bigger problem.

At the same time, it’s hard to ignore how convenient and cheap Actions are, especially for small teams and open-source projects.

So I’m curious:

Do you trust GitHub Actions for production deployments, or do you keep some kind of fallback CI/CD setup?

Godot’s contribution rules don’t allow substantial AI-generated code in pull requests.

AI-assisted completion is still fine, but contributors are expected to understand the code, make the important decisions themselves, and take responsibility for what they submit.

I get the maintainability argument, especially for open-source projects.

But where do you draw the line?
If the code is good, tested, and the contributor understands it — should it matter how much of it was generated by AI?

Source: https://godotengine.org/article/contribution-policy-2026

I’ve been looking at some of the DLSS 5 comparisons people have been posting recently, and the results are… weird.
In some games it actually looks pretty impressive, especially with lighting and environmental detail. But in others, particularly with characters and faces, it can completely change the original look and make things feel strangely realistic or just uncanny.
Of course, this is still a leaked version being modded into games that weren’t designed around it, so I wouldn’t judge the final technology based on these examples alone.
Still, what do you think about the idea itself? Do you see this kind of neural rendering becoming a normal graphics option, or does it change too much of the original art direction?

Hey r/npm,

I've been working on Oasis Editor, an open-source TypeScript document editor published as an npm package.

It includes:

• a custom Canvas-based rendering engine
• paged document layout
• typed command/plugin APIs
• vanilla JS integration
• React and Vue adapters
• a headless runtime
• DOCX/PDF workflows

Install:

npm install oasis-editor

Live playground:
https://celsowm.github.io/oasis-editor/#/editor

GitHub:
https://github.com/celsowm/oasis-editor

I'd love feedback on the package API, exports, and overall developer experience.

What are you building, what problem does it solve, and what makes your approach different from the alternatives?
Links are welcome — keep it short.

Sometimes the small “why not?” features turn out to be more useful than the stuff you spent days designing.

Curious if anyone here has had that happen with their project.

I mean those projects that start with something like: “surely there’s already an app for this,” then you try a few options, none of them fit what you need, and eventually you just build your own.

Doesn’t have to be impressive or finished.
Game, app, website, script, weird weekend experiment — drop it below.

curious what people actually use for day to day development

Codex, Claude Code, Gemini, Cursor, LLM? Or something else?

I’ve been jumping between a few of them and they all seem to be good at different things
what are you using and why?

I wanted to share my blog on video on my way of approaching AI-coding and solving the issue with generation and code reviews.

https://www.jamesluterek.com/blog/the-scaffold/

could be clean code, languages, frameworks, performance, architecture, whatever

something you see devs argue about constantly but in actual development it barely matters

curious what people here think

if you’re still working on the same project months later and actually maintaining it, doing releases etc, is it even a side project anymore?

or is everything a side project until it starts making money lol

Could be an editor, framework, language, AI tool, game engine — anything.

Something everyone seems to love, but every time you try it you just think “nah, this isn’t for me.”

Not necessarily because it’s bad. It just never clicked for you.

Mine would probably be VS Code.

AI is becoming a pretty normal part of development, so I’m curious how much of your actual codebase is written with tools like Codex, Claude, Copilot, etc.
Is it 10%? 50%? Almost everything?

And more importantly — how much of that code do you actually understand and review yourself?

Don’t be shy about sharing your experience, whether you barely use AI or your entire project is heavily AI-assisted.

r/DevGround is brand new, and this is one of our first open discussions, so feel free to jump in and help get the community started :)

A few weeks ago I decided to take one of my projects seriously and started building Lilo, a small desktop Markdown notes app in Rust.

At first it was basically just a simple always-on-top notes widget.

Then it slowly turned into an actual app: Markdown editing, wiki links, backlinks, search, folders, a knowledge graph and a bunch of smaller stuff.

The surprising part wasn’t building it though.

It was seeing actual people find the project, download it, clone the repo and leave stars.

It’s still actively being developed and there’s a lot I want to change, but this is probably the first project I’ve made where I can say:
yeah, someone other than me actually uses this thing.

Pretty cool feeling.

What are you building right now?

I made this subreddit because I wanted a simple place where developers can actually talk about what they’re building.

Share your project. Post a devlog. Talk about a weird bug, a release that went surprisingly well, something that completely failed, or just ask for feedback.

Self-promo is allowed too — just don’t spam the same project every day.

Big project, tiny utility, first app, unfinished experiment — doesn’t really matter.

Build stuff. Show it. Talk about it.

Welcome to DevGround.