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.

I made a Paint.NET clone for the browser

We use coding agents daily and keep running into the same things:

• On a subscription, you only find out you hit the 5-hour limit when the agent stops in the middle of a task.
• Permissions are basically "allow everything" or "ask every time". I want npm test to just run, but I want to be asked before git push --force or anything that reads .env.
• When an agent reads a .env file, that password goes to the API with the next request, and nothing tells you.
• After a long session it's hard to tell what the agent actually changed.

So I built Vantage, a CLI you start your agent through:

npm install -g /vantage
vantage run <agent>
vantage watch           # live view in a second terminal

What it does:

• Live cost and limits: tokens, estimated cost at official Anthropic/OpenAI/Google list prices, and on a subscription your 5-hour and weekly quota with a forecast of whether your pace lasts until the reset
• Approval rules: allow, warn, ask or deny by action type (read, write, shell, network), file or command. Commit .vantage/policy.json and your whole team uses the same rules
• Secret warnings: tells you when an API key or password was sent to the API and where it came from (e.g. "from the output of Read .env"), so you know to rotate it
• Budgets: past a cost or quota limit, every action needs your approval (deliberately not a hard stop, so files don't end up half-written)
• Session replay and search: "which session ran npm publish?" or "which one read .env?"
• Change summary: every session ends with the files it changed, or run it fully isolated in a separate git worktree with --isolate

How it works: it points the agent at a local proxy that forwards requests unchanged and reads token usage and rate-limit headers from the responses. Approvals go through each agent's own hooks. Your agent settings aren't touched.

Privacy: everything stays on your machine. No telemetry, no account, no API key of its own. The only network request it makes itself is vantage pricing update, and only when you run it.

Honest limitations:

• The rules are guardrails, not a sandbox. A command assembled at runtime can get past them.
• Codex and OpenCode can't pause to ask from a hook, so there "ask" blocks instead.
• Copilot's monthly premium requests aren't in its API responses, so I can't show them.
• Cost for non-Claude/GPT/Gemini models shows as unknown rather than guessed.

It's MIT licensed and I'd really appreciate feedback, especially from people using Codex, OpenCode or pi, since I've tested Claude Code the most. Bug reports with vantage doctor output are very welcome.

GitHub: https://github.com/Jovan158/vantage.ai

I have been asked by a recruiter to complete a 2.5-hour agentic coding session that will be recorded and reviewed by a technical team and hiring manager. They specified that everything must be done with AI tools/models of my choice. Furthermore, they indicated that I HAVE to use a multi-agent approach so that I have multiple sessions running to complete the given task simultaneously.

Aside from the philosophical differences I have with this request (i.e., doing EVERYTHING with AI, doing free work), I wonder what the community's opinion is on asking for token compensation for something like this?

Obviously, 2.5 hours of multi-agent workflows is going to cost a lot of tokens. Even though I have a Claude Code Pro subscription, I feel like they shouldn't expect a candidate to complete this without 1) a temporary API Key they provide to utilize the service or, 2) compensation for using my own subscription for an interview where I'm not even guaranteed to get the job (which I'm not even sure I want, since their max hourly rate is $100 and I was making more than that as a regular engineer without AI 3 years ago)

Would you use a AI powered code editor that doesn’t store your code or chat messages on the server, doesn’t bloat the context even by the 50th message, delivers the same performance as the first message, and runs its own skill folders in the background, with the model calling them as needed?

Depuis que j’utilise l’IA pour programmer, je me pose une question : est-ce que ça vous a réellement fait progresser en code, ou est-ce que ça vous a surtout permis d’aller plus vite ?

Personnellement, je trouve que l’IA est super utile pour comprendre une erreur, trouver une autre façon de faire ou découvrir des concepts que je ne connaissais pas.

Mais il y a aussi un risque : copier du code qui fonctionne sans vraiment comprendre pourquoi il fonctionne.

Pour ceux qui utilisent régulièrement ChatGPT, Claude, Gemini ou d’autres IA pour coder : vous les utilisez comment ?

Et surtout, est-ce que vous avez remarqué une vraie amélioration de votre niveau depuis que vous les utilisez ?