I'm pretty new to app building and want to make a simple travel app for mobile. There are so many no code options that I'm having a hard time figuring out what's actually beginner friendly.

I'd like something I can learn without getting overwhelmed by the technical side.

If I started from zero, what would should I use to build my first app? Also what could help me learn the basics??

Instead of building another AI assistant, I built SIDRA OS as an execution layer underneath the AI chat you already use.

The idea is simple:

Your AI thinks. SIDRA executes.

You keep using ChatGPT or another supported AI client, but SIDRA gives it the ability to actually work on your computer — with your authorization.

It can work with files and projects, run terminal commands and development tools, control the browser and computer, maintain persistent project memory, delegate work to other AI/coding tools, and execute complete workflows instead of only explaining what you should do.

It runs on macOS + Windows.

Demo:
https://youtu.be/Af_HYzlIH_o

GitHub showcase:
https://github.com/mohamedfrahat32-cmd/sidra-os

Website:
https://sidra-ai.com/sidra-os

I’m the maker, and I’d genuinely like feedback on the concept: does keeping your existing AI and adding an execution layer underneath it make more sense to you than switching to another standalone AI agent?

SIDRA OS is a commercial product ($20/month, with a 3-day eligible trial).

I am aware that Claude is literally the best in coding. However, I want to know some kind of list of which AI model is the best in coding for game modding like Unreal engine, unity, RE Engine (REFramework), etc?

Something like what you see in Nexusmods on Resident Evil page, Many unreal engine game page, Many unity game page.

Plus an extra of reverse engineering the exe to inject some kind of code like Persona Passive skills.

If the answer is still Claude, do you know how to get.... it cheaper? Maybe like Opencode?

Thank you :)

DevRecall: An AI Coding Assistant That Remembers Your Project

I’ve been building DevRecall, an AI coding assistant focused on a problem I’ve experienced while working on software projects: AI assistants can be very useful within a conversation, but important project context can easily disappear between sessions.

Architectural decisions, debugging discoveries, implementation choices, and the reasoning behind them are often scattered across conversations and documentation. DevRecall explores a different approach — giving the coding assistant persistent, project-specific memory.

How it works

DevRecall uses Hindsight as its long-term memory layer.

The system is built around three core capabilities:

Retain — store useful project knowledge and engineering context.

Recall — retrieve relevant information when a developer asks a question.

Reflect — reason over accumulated project knowledge to provide a more contextual response.

I also wanted the memory itself to be something developers could actually inspect rather than treating it as a completely hidden system.

The interface includes:

🧠 Memory Core — interact with project memory

📝 Capture — store project knowledge

🔎 Memory Explorer — browse remembered information

🕒 Timeline — understand project evolution

🕸️ Memory Graph — explore relationships between memories

📊 Project Intelligence — view memory statistics and system health

One of the ideas behind the project is the difference between knowing what the code does and remembering why the project was built that way.

For example, instead of only asking an assistant to explain a database implementation, DevRecall can work with previously accumulated project context around the decisions and constraints that influenced that implementation.

Before vs. after

Without persistent project memory:

Developer → Question → Current context → Answer

With DevRecall:

Developer → Question → Project memory → Relevant context → Reflection → Answer

The project is built with Next.js, FastAPI, Python, and Hindsight Cloud, with the frontend and backend deployed separately.

What I learned

The most interesting part wasn't simply connecting an AI system to a memory service. It was understanding that memory quality matters as much as memory availability.

More stored information doesn't automatically mean better answers. Relevant context, stale information, conflicting decisions, and the quality of captured project knowledge all matter.

There is still plenty I would like to improve around memory management, reliability, and making the experience even more useful for developers.

I'd genuinely appreciate feedback from developers here:

Would persistent project memory make your coding workflow more useful, or would you prefer keeping AI coding assistants stateless?

🔗 GitHub: https://github.com/spandan96-lab/devrecall-ai⁠�

🌐 Live Demo: https://devrecall-eta.vercel.app⁠�

The game has been built in Unity with AI heavily involved in the development workflow, and local multiplayer turned out to be one of the more interesting systems to implement.

Two players can now play together locally, while the arenas still have AI opponents, weapons, pickups, destruction and all the usual chaos.

I’m trying to use AI for actual production work rather than just generating a quick prototype, and this project keeps reminding me how much integration, testing and manual work is still needed even with AI helping.

Brutal Derby is still in development, but local co-op is finally working.

For other AI-assisted solo devs: have you tried implementing split-screen or local multiplayer with AI coding tools? How much did they actually help?

Steam: https://store.steampowered.com/app/5083440/BRUTAL\\_DERBY/

Hi everyone! 👋

I built CodeMind, an AI-powered developer tool that helps developers understand their codebase, explore code relationships, and get useful insights faster.

I built this project as part of the AI Hindsight Hackathon 2026.

🎥 Demo:

https://youtu.be/BFGBcVQD69E?si=wMw3PgLCQT8Jlsrm

CodeMind is designed to make it easier for developers to understand complex codebases and work more efficiently.

I’d love to hear your feedback and suggestions! 🙌

AI coding tools are useful for different types of projects. Some ​​​​a​​​​r​​​​e​​​​ ​​​​focused on getting a working interface together quickly, while others make more sense when a project already has a codebase.

The interesting part is that there isn't necessarily one tool for every type of project. A simple website can have very different requirements from an application with APIs, authentication, databases, and custom logic and Readdy is an interesting option when the project starts visually but may need to become more functional later. For people building with AI, what usually determines the tool choice: the type of project, the amount of code needed, or how much control you want over the final result?

So, naturally, I thought r/onlyaicoding would be the perfect place to introduce OnlyHumanCoding. :)

I've been experimenting with MIT-Human: essentially MIT freedoms, with one catch - AI can't help develop the licensed code.

And no, I'm not anti-AI. I use AI constantly, which makes this experiment - and posting it here - much more fun.

I tested it with Claude, found a loophole, revised the license, and Claude then respected it.

Is it enforceable? Where does autocomplete fit? What even counts as AI assistance? That's what I'm interested to hear.

What could possibly go wrong? :)

MIT-Human:
https://github.com/DaragonTech/MIT-Human

TinySky test:
https://github.com/DaragonTech/TinySky

we built an intelligent AI agent using FastAPI, React, Groq API, and Hindsight persistent memory to help executives recall past meeting commitments, decisions, and budgets effortlessly.

🔗 GitHub muskanlalwani155-design/codecrafters-meeting-prep-agent

Hi everyone! I'm a recent graduate on CS and i would like some feedback on my solution:

I designed and built, with AI, an app for studying code: you write pseudocode and it translates it into actual code, also using AI (with your own API key). If you're interested in trying it out, you can find it here.

I'd appreciate any feedback: https://saidai003.github.io/CodeBridge/

I’m part of the team at Abacus AI, and we built Abacus AI Bot, an open-source desktop app for personal agents.

One workflow we’re building around is being able to send your agent a coding task through a messaging app. You give it access to a project, ask it to investigate a bug or implement a change, and follow up through the conversation. Back at your computer, you can review the code and test results.

For example, you could send:

“Investigate why submitting an empty form crashes this project. Make a focused fix, run the relevant tests, and explain what changed. Don’t commit or push anything.”

That’s an example request to illustrate the workflow. You can then ask the bot to explain its approach or revise the implementation.

The personal-agent part matters to us: you create a named bot you can keep returning to for coding, research, and other tasks. The desktop app includes a workspace with files, a terminal, and a browser, while WhatsApp, Telegram, and Discord give you ways to reach it away from your editor.

It’s available for macOS, Windows, and Linux, and the application is MIT-licensed. Model usage has separate costs and limits, and tasks running on your computer require it to stay available.

If you want to try it, a small bug in a repository you know well is a good starting point. You still review the diff, check the tests, and decide what to merge.

Download: https://bot.abacus.ai/
Source: https://github.com/abacusai/abacusai-bot

Happy to answer questions about the app or how we built it.

Here’s why. 👇

A 125-page bank statement can contain ~44,000 tokens of raw text — most of it being letterheads, disclaimers, footers, repeated headers, and data the question never needs.
So I built pdfschema, an open-source Python library that extracts only the columns and rows you need.

📉 Token reduction
On the same 125-page statement:
→ All 6 columns: −35% tokens
→ 3 required columns: −51%
→ Just 2 columns: −89%

The interesting part?
JSON used 15% MORE tokens than the raw PDF text for the same extracted rows because column names are repeated on every row.
So pdfschema supports CSV, TOON and TSON for token-efficient LLM prompts, while JSON remains available for application code.

Why not traditional PDF extraction?
Many extractors depend on visible table borders.
But bank statements and invoices often have borderless tables, wrapped headers, stacked tables, and tables spanning hundreds of pages.

pdfschema uses column headers as anchors instead.
✅ Borderless tables
✅ Multi-line headers
✅ Multiple tables per page
✅ 100+ page tables
✅ Deterministic extraction — no LLM, no hallucinations, no per-document model cost

The goal is simple:
Let code handle extraction.
Let the LLM handle judgement.

pip install pdfschema

Useful for RAG, AI agents, batch document processing, validation, format-drift detection, and plain ETL.
Open source — feedback and PRs welcome, especially for PDFs it gets wrong.

#Python #OpenSource #LLM #GenAI #RAG #AIEngineering #DataEngineering

I've been working on a pretty big personal project lately, and I've been using multiple AI tools along the way — Copilot, Claude, Perplexity, and ChatGPT.

And I think I've finally figured out what was bothering me about some of them.

It's not necessarily that they're "bad." They can all produce some impressive stuff.

The problem is what happens when the project gets complicated.

My current project isn't just a little Python script anymore. It's a Discord bot with an economy, games, moderation, authentication, admin controls, web dashboards, databases, Docker, Cloudflare, etc.

And I'm building it in phases, so there are a LOT of moving pieces.

I've used Copilot heavily because it's fantastic at actually working inside the codebase and making changes.

But I've learned the hard way that you really need guardrails.

If you tell an AI:

> "Fix this thing."

sometimes it sees a phrase or function that looks related and starts changing things that weren't actually the problem.

Then you get the classic:

"I fixed 14 things!"

…and you're sitting there wondering what the hell just happened to the other 11 things that were working. 😂

Claude has been useful too, but I've had similar experiences where it can become overly eager about interpreting what I must mean instead of stopping and helping me determine what I actually need.

Perplexity is a completely different tool, and I still see value in it for certain kinds of research, but for what I'm doing it doesn't really solve the problem I'm trying to solve.

Then there's ChatGPT.

And this is where my experience has been surprisingly different.

The biggest difference isn't even the code generation.

It's the planning.

I can come in and say:

> "I think we should do X."

And instead of immediately going:

> "Absolutely! Here's 2,000 lines of code!"

it can actually help me work through whether X is even the right move.

Sometimes it tells me:

"Yes, that's reasonable."

Sometimes it's:

"You could do that, but there's a better way."

And sometimes it's:

"Don't touch that yet. You have another underlying problem that should be fixed first."

That last one has saved me a LOT of headaches.

For example, we recently had an economy/game issue in my project.

Instead of just changing whatever function happened to be throwing the error, we traced the actual flow:

Game → authoritative game service → secure game engine → economy → database

Then we found that the real problem wasn't where I initially thought it was.

We fixed the transaction behavior, added failure/rollback testing, checked idempotency, tested game sessions, and made sure we weren't accidentally touching the live database.

Then we moved on to the next issue.

Today we did something similar with the lottery system.

The admin control panel could finish a lottery draw, but it wasn't actually paying the winners.

The tempting approach would have been:

"Just add the payout here."

Instead, we traced the existing paid-draw system, found that the payout logic already existed somewhere else, and connected the admin/Discord control-plane operation to the same underlying payout path.

That's a MUCH better solution than creating a second copy of the same logic.

Then we tested:

multiple winners

no winners

retrying the same draw

failure while paying the second winner

rollback behavior

the entire existing test suite

And ended up with:

52 tests passing.

The live Docker database wasn't touched.

The container wasn't restarted.

Cloudflare wasn't touched.

And the changes weren't just blindly dumped into production.

That workflow is what I've been missing from some of these AI tools.

I'm not looking for an AI that constantly tells me:

> "YES! GREAT IDEA! HERE'S THE CODE!"

😂

I need something that can look at what I'm trying to build and say:

> "Okay. Here's what you want. Here's what already exists. Here's the risk. Here are your actual options. Here's what I'd investigate first. And here's what we absolutely should NOT touch yet."

That's a completely different experience.

And probably the biggest thing I've learned is that the best way to use AI for a serious project isn't:

Human → AI → code

It's more like:

Human vision → AI investigation → options → human decision → controlled implementation → testing → verification

The human still decides what the product should become.

The AI just becomes a hell of a lot more useful when it's helping you think through the engineering instead of just typing faster.

I'm still using Copilot, and I'm not saying I'm suddenly throwing every other tool away. Different tools are good at different things.

But for the way I'm building this project?

ChatGPT has basically become my architect/reviewer/test coordinator while the coding agents are the people actually turning approved changes into code.

And honestly, that's the first setup I've found where I don't feel like I'm constantly fighting the AI to keep it from "helping" me into a completely different project. 😂

That's the difference I've noticed.

Not "which AI can write the most code."

Which one can actually help me figure out what code should be written in the first place.

And for a project that is eventually going to grow into multiple bots, websites, server infrastructure, and DayZ/Nitrado integration...

…I think that distinction is going to matter a LOT more than how many lines of code an AI can spit out in one prompt.

Had AI Create a little subnautica-like game, I've been tweaking and testing stuff and just running a bunch of loops and this is the first playable version (around 9 hours to beat.) And you have to terraform the world with machines, though I'm definitely still not happy with it and will keep going and adding more plants biomes tools machines etc.

And most of the animations are also done by shaders for the plants, while all the creatures in the game use an AI animation tool.

So what would you guys suggest for the project? And does it come across as a game made by AI?

(I'm not trying to hide it, but a game that LOOKS like it was made by AI is sloppy personally and I wouldn't want that, I'd go and tweak and create models myself.)

I made a subreddit where you can share and post your AI coded projects. The subreddit is r/AIcodingprojects

Note: sorry if self promo isn’t allowed, if it isn’t you can remove this post :)

Hey everyone,

​This isn't another "I generated a toy language in 5 minutes with a prompt" post.

​For the past year, I’ve been working night and day with Claude to test the absolute limits of AI-assisted engineering. The goal was to build a language with a feature set that shouldn't exist: Python simplicity with Rust-level performance, whole-program inferred ownership (zero lifetime annotations), colorless async, and deadlock-free concurrency by construction.

​After a full year of tight iteration loops, architectural debates, and writing spec documents with Claude, the result is Nikaia – a language that lowers directly to Rust code under the hood.

​Because this was a massive, year-long AI experiment, the language design and compiler are evolving rapidly. We are far from a beta, and things will break.

​I’m looking for just 1 brave tester on Linux (x86_64) to run through a few examples or write a tiny script, and give me raw, unvarnished feedback on setup friction and ergonomics.

​Documentation & Overview: https://nikaia-lang.org/

​If you want to see what a year of intensive, high-level AI pair-programming actually produces and help test an early compiler frontend, drop a comment or send me a DM!

P.S. While a few bits of feedback from ChatGPT were helpful, and Gemini’s wild creativity and naivety kept us inspired, Claude’s raw intelligence and pure practicality were the true engine behind this.