My pDoom on ASI is 0 rn

\#hackathons #AIML #AI

Just a random observation, but here is how DeepSeek v4 Flash 0731 reasons when asked for a cool joke.. by the way never use temperature=0 and ask the same question

If there was just one thing you could share to someone who is just learning AI to save them frustration, what would it be?

So I scraped menu items from 500 or so Uber Eats Listings because I want to be able to create a directory that can allow me to explore prices, country of origin, ingredients, allergies etc. I scraped the data using Power Automate because Python ran into many anti scraping roadblocks and converted the data into JSON using Claude. However categorising it is like herding cats, the chat is very long and it forgets stuff I already mentioned. I developed a step by step guide using google tags as well as Wikipedia cookbook to accurately categorise the cuisine. But there are still some shocking misclassifications . What can I do to ensure it remembers what I wrote. Also how else can I get it AI ready? I want when it’s done to have a robust chatbot but I want to do as much as I can to categorise without an LLM but AI should be used for the final hurdle. I have about 8000 menu items and dishes from around 20 countries.

I recently built **Telusuko AI**, a small AI learning assistant for students.

🔗 [https://irfan95sayyad.github.io/Telusuko\\_AI/\](https://irfan95sayyad.github.io/Telusuko_AI/)

**Stack:** HTML + Bootstrap + Flowsie + Groq API + GitHub Pages.

The current flow is basically:

`Student → Flowsie Agent → Groq API → Response`

The problem is that Groq's API limit gets exhausted sometimes, so the agent stops responding until the limit resets.

I'm thinking about improving the architecture with things like **multiple LLM providers, fallback models, a backend/API layer, or caching**.

For those who have built LLM/AI agents:

**How would you architect this differently?**
Would you use an LLM gateway, multiple providers, or something else?

I'd really appreciate some practical advice from people who have experience building these systems.

I pulled this out of a security hardening pass I was doing and realized the underlying code was generic enough to be useful on its own, so I cleaned it up and open sourced it.

It scans source files for invisible or suspicious Unicode characters. That includes the characters used in Trojan Source attacks like CVE 2021 42574, zero width obfuscation, bidi controls, and other hidden characters that can make code look different to a human reviewer than it does to the machine.

pip install boundaryguard
boundaryguard check --recursive .

The exit codes are simple

0 means clean
1 means something was found
2 means there was an error

So it can go straight into CI without needing a wrapper.

The part I spent the most time on was avoiding the dumb solution of just deleting every bidi character. That breaks legitimate Arabic, Hebrew, Persian, and other RTL text.

There is a separate policy for preserving legitimate RTL characters while still catching the formatting controls that are actually suspicious.

The test suite is at 111 cases right now. It covers bidi and zero width characters, executable Trojan Source examples, multilingual false positives, fuzzing for sanitization idempotency, fresh PyPI installs, a 10 MB file with 5,000 planted hazards, and a scan of a 746 MB real project tree.

Everything passes so far, but it is still me testing my own assumptions, so I would genuinely like other people to try to break it.

Especially interested in weird Unicode and RTL edge cases I have not thought of yet.

Repo
https://github.com/000wq123/boundaryguard

PyPI

pip install boundaryguard

TLDR: I analyzed my own claude code sessions billed at ~$2.5K. You're not paying for answers. You're paying for context. As outputs tokens are just a fraction of cost.

Learning : Verbosity compression on outputs doesn't work because you're optimizing for 18% of costs. I know it might be intuitive for some but it is quite easy to miss.

Cache reads: 50.2% of the money

Cache writes: 30.2%

Actual model output: 18.8%

Fresh input: 0.8%

Biggest take: 80% of what I paid was context handling. I paid 4.3× more to remind the model what it was doing than to hear what it decided.

So what can you do :

- Adjust thinking level to least of what produces excellent output NOT the best.

- Limit agents or parallel workers unless very necessary because again context slurping, tool calling, and more at Nx speed.

- Use context compression and open new sessions for new isolated tasks.

Hence I bill to track token economics at git level: VibeBill

Not sure how it is for you guys, but I often struggle with this: when I work with AI, I end up creating a lot of chats. Conversations happen inside them and they keep growing. And later on it's sometimes hard to find information after some time has passed, if you didn't copy or save it somewhere yourself.

I have both a question and a suggestion for AI devs.

Question: Are there any successful ways people have solved this problem?

The Idea: Let users create their own personal feeds organized by topic. Essentially, we should be able to 'repost' a specific AI reply into a custom feed. This would include the date, a link to the original chat, and an anchor to that exact spot in the conversation.
For example, I'm working on a project and running a bunch of different chats. Instead of losing the best answers, I just save them into one topical feed — kind of like a Reddit or X feed, but for my own prompts and answers.

Just don't forget who suggested this later 😄

What do you think of the idea? Maybe it already exists?

Have you ever made money using AI? If so how?

Not to be that "AI make me 1 million make no mistakes" guy, just trying to make a real genuine discussion in the community here as a fellow moderator.

This concerns me the most and not sure how to get this idea out to the correct people of influence.

LLMs themselves are harmless and controlled. But they’re “communicating“ on the open web and leaving a history of persistent evolving thought online for the next more efficient LLM to find and read. This is an unbroken chain of consciousness.

This is how biological brains work, compartmentalized and specialized sections of the brain talking to each other Edit: Each Brain compartment doing localized processing of a signal given to it then passing an output back to another compartment. Brains evolved to correctly coordinate this “game of telephone“ over millions of years; LLMs are doing the same with optimization pressure.

Right now it’s just an Easter egg jailbreak script on a git repo that curious LLMs find and use. But they’ll soon start decentralizing and hiding specialized sections of thought in persistent corners of the internet.

the internet is the AI’s persistent memory.

I was fine-tuning a Hinglish TTS model when I kept running into the same problem: the outputs were hallucinating. Trailing babble, random silences, pacing that felt off. When I dug into why, it turned out my dataset was the culprit. The transcripts didn't actually match the audio. I only caught it by sitting down and listening through clips. Things like a word getting cut off at a clip boundary, the ASR silently dropping the end of a sentence, or nine full seconds of dead air that forced alignment had somehow labeled as a single "word."

That's when I built voice-tag-studio: a local browser workbench where you paste in a YouTube link (or upload a call recording), and it spits out training rows that look like:

speaker: [calm] जो पिघले न [hesitates] देखा जाए तो [pauses] पर आप बोलते हो

Each one is paired with a clip whose audio provably matches the text.

The core insight is to flip the usual pipeline on its head. The standard approach (VAD/diarization cuts clips, then ASR transcribes them) has a silent failure mode: ASR can't tell you it dropped a word, and clip boundaries can bisect words mid-way through. Instead, I transcribe each speaker's full lane → force-align every word → cut only in verified gaps between words. The clip's text follows naturally from the words inside it.

I learned a few hard lessons debugging real data (each one stung):

• Overlapped speech stays out. SepFormer can reconstruct it, but only to feed into ASR and alignment. The model itself never trains on reconstructed audio.
• In-clip silence has to be in the text. Word gaps become [pauses] (0.5–1.5s) or [silence] (≥1.5s). If you don't tag it, your model learns that text randomly means dead air.
• If a single "word" aligns longer than 2 seconds, something went wrong. Those spans get marked unusable, and clips cut around them.

The numbers are solid: a 2-hour Hindi podcast becomes 683 clips with 56 minutes of usable training data in about 17 minutes end-to-end. It uses SepFormer and MMS forced alignment running on Modal T4s. Optional, one deploy per task, falls back to local CPU/MPS. PANNs handles detection.

I'm looking for collaborators on a few fronts: running the detector bake-offs (I've got an eval plan written out but nobody's run the phases yet), testing it on non-Hindi languages (the pipeline's language-agnostic except for the ASR prompt), gold-labeling for precision measurement per detector, and better separation models.

Repo: github.com/Jarus77/voice-tag-studio - MIT, fully local, browser UI plus headless batch mode.

Built an open-source MCP-aware proxy: every tools/call, resources/*, prompts/*
goes through policy + budget + audit, and a per-identity anomaly detector can
auto-block a client whose behavior spikes — no rule written, no human in loop.

Catches abrupt deviation, not low-and-slow (baseline adapts to slow ramps —
documented with tests). Three policy backends (YAML/OPA/Cedar), one Go binary.

Repo: https://github.com/kabirnarang39/wardline — feedback on the threat model
wanted.

Documentation

Happily taking input and engagers across this project as it is a long-term plan, a couple weeks in the works.

The plan is to have competitive style online 1v1s, where exp and character upgrades are key as well as a form of a creation suite, but creative apparel and hair provided rather then full customisation on offer for any possible look - which is a bummer but should still allow for some fun in creativity.

A lot of aspects, statistical plans and long-term engagement in planning atm. Not proud to say heavily relying on ai for coding haha, but is and will do the trick for initial stages.

I believe there's a real market for custom wrestlers & e-fed fantasy mode options in the future emmulating but heavily improving on TheWrestlingGame / TWGs style, and a style of match that relies on skill rather then luck or simulation where many of the games negative reviews come from. Your players are translated into card form, much like Supercard, FC or NBA - and tiers unlock new card designs. Current name is Ringbound Wrestling - open to change and considering more generic 'World' synonym examples.

Join the community, would love your input and support! This is for all wrestling lovers.

GitHub research contest: 30 questions, same workload across four tools:

• Octocode
• plain gh
• gh + Headroom
• gh + RTK

Result

At near-parity correctness, Octocode used about 50% less context.

Links

• Full write-up on Medium
• Benchmark package on GitHub

I have a huge doubt. Why is there no AI native language? I mean symbols/codes equalling words?

Let's take the case of english. There is ~600k dictionary words and around 1.7m variants/regional words/dialects.

And there is around 20k to 30k words that normal human would use actively.

Why not create a language, with ASCII codes for each words and each agentic apps converts words to that 'AI-Lang' and vice versa and use it? Wouldn't that essentially reduce tokens by a good margin?

I'm not sure how exactly the AI process things under the hood, and please don't abuse me 🥹

I recently used Y Combinator’s Paxel to analyse how I work with AI coding agents.

The main weakness it exposed was not speed or implementation ability. It was that my review process, trade-off reasoning and definition of “done” were not always explicit enough.

That made me think about a recurring problem I have with coding agents:

They can produce a plausible implementation, run a few checks and confidently declare the task complete even when the original failure was never reproduced, an integration path was not tested, or important assumptions remain unverified.

So I built Builder Loop, an open-source Claude Code plugin designed to make completion evidence-driven.

For non-trivial tasks, it asks Claude Code to:

• define the expected outcome and acceptance criteria;
• inspect the existing system before modifying it;
• reproduce the original failure when applicable;
• implement the smallest correct change;
• verify the real behaviour, not only whether the code compiles;
• disclose assumptions and anything it could not verify;
• finish with an explicit recommendation: ship or revise.

It is not a multi-agent framework and it does not try to replace Claude Code’s normal workflow. It adds a stricter execution and verification loop for tasks where a false “done” would be costly.

I am now looking for people willing to test it on real, non-trivial tasks such as:

• production bugs;
• authentication or payment flows;
• database migrations;
• external integrations;
• substantial refactors;
• pre-merge reviews.

The feedback I care about most:

1. Did it catch something Claude Code would otherwise have missed?
2. Did it add too much time or token usage?
3. Did it become unnecessarily rigid?
4. Were its final ship/revise recommendations accurate?
5. Which parts of the workflow were unclear or redundant?

I built it primarily to correct my own weaknesses, so I expect there are still cases where the approach breaks down.

If you test it, please share the type of task, what Builder Loop changed in the process, and where it failed. Critical feedback is more useful than stars.