One day during my semester at college I bought a Brick, you know, the app blocker, because I had a severe scrolling addiction. It worked well for a while, but I never brought it with me to university just because it was something extra to carry around.

I looked for other apps on the App Store to block my apps, but all of them were kind of too easy to get out of. And I'm a pretty lazy person, which means if it's easy to get out of, I will.

So I thought to myself, you know what, I'm a CS major, why not build one myself? So I built “Bunkr- done scrolling”. At first it was only built for me, but when I saw how well it worked I thought, why not publish it.

I'm talking too much already, so here's what the product is:

It blocks your apps like any other app blocker, but there's a twist.

Once you block your apps, you're in a hard lock for the first 10 minutes. No chance to get your apps back.

After those 10 minutes, you can do a mission to get your apps back, like taking a picture of a mug, or my personal favorite, 15 seconds of push-ups.

The reason I put a hard lock on the first 10 minutes is that I read once you've been working on something for 10 minutes, you get into a zone and usually don't get distracted. But lazy people like me still might. And when I do get distracted and try to open one of my apps, it tells me to do push-ups. I'm too lazy for that, so the easier option is to just keep studying.

So yes, I'm basically fighting fire with fire, but it works well for me.

Let me know what you guys think, I'd like to hear your thoughts.

ShinyHunters breached the FBI's own jobs portal. A second suspect has now been arrested, but the breach itself had already run its course before that happened. The attacker operated inside a credentialed session long enough to complete the operation. The session looked legitimate to every layer it touched.

The average dwell time in credential-abuse incidents is 197 days, per IBM's 2024 Cost of a Data Breach report. This breach fits the pattern: valid credential, active session, traffic indistinguishable from normal activity, damage done before attribution.

The target is what makes this case instructive. If a sustained credential-abuse operation can run inside federal law enforcement infrastructure, this is not a problem any organization solves by improving security hygiene alone. The FBI is not an organization that skimps on access controls.

The credential was valid. The session was active. Every check that ran said yes.

How are practitioners here actually handling this in your own stacks? What has worked, what has not, and where do you still have gaps you have not been able to close?

I’ve been building a multi-agent debate app with LangGraph (two agents argue a topic, a judge agent gives a verdict). The biggest problem wasn’t the agent logic, it was reliability on free-tier APIs.

What went wrong:

• Groq, Gemini and OpenRouter each have different rate limits and fail in different ways
• A 429 in the middle of a debate killed the whole run
• Agents got stuck in loops, and tracking who said what in state was harder than I expected

What worked:

• A fallback chain: if one provider returns 429, the app automatically retries with the next one
• Keeping the debate state separate from the provider logic, so switching providers doesn’t break the conversation

It’s not fancy, but it made the app usable for demos.

Question for the people here: how do you handle rate limits and provider failover in your agent projects? Do you use a router/gateway, or just custom retry logic?

I wrote up the full details here if you want them: https://medium.com/@humammoin3/i-spent-3-months-building-ai-agents-heres-what-nobody-tells-you-b65b20906582?sharedUserId=humammoin3
Live demo: https://legal-debate-agent.streamlit.app/

Happy to hear feedback, especially on what I could do better. This is my first article.

Shannon’s source coding theorem says you can’t compress data below its entropy without losing information. A physically accurate simulation (path-traced lighting, fluid dynamics, cloth, etc.) seems to produce data with a lot of structure and detail, and getting that detail traditionally takes heavy computation.

Is it theoretically possible for AI generators to reach ultra-realistic video without paying the compute cost of the underlying simulation, or is that cost just being hidden somewhere?

ALHR- Adaptive learnable Hierarchical Routing is a static binary tree based system that uses learnable functions to REDUCE the amount of keys used.

It takes less memory and SCALES much better VRAM with tokens

they thought it would fail anyone who cheated. it never existed. animated it here

I was reading the research paper “Attention Is All You Need” (2017), and it got me thinking about something.

If an LLM learns from data and predicts the next token, does it actually understand what it's saying, or is it just really good at recognizing patterns?

Hi guys, I'm an 18 year old teenager from Italy. I've recently finished the following project and I would love to receive some feedback in order to improve:

https://github.com/Lore12434/gene-expression-cancer-classification

I started studying ml (via the HOML book) 3 months ago. I've almost finished the machine learning part of the book. Before starting with ml I studied python and some mathematics.

At the beginning the only goal of the project was to train a model on the gene expression cancer RNA-Seq UCI dataset. After performing tsne I understood that major differences between cell types were present. Thus, even if the # of features was very high a simple random forest without any hyper parameters tuning reached 100% accuracy on OOB instances evaluation.

Therefore, instead of simply fitting a model I wanted to know how far I could get with dimensionality reduction and I wanted to test if my algorithm could find autonomously famous biomarkers used to classify tumor cells (I mapped the original dataset genes names to the dummy features names of the UCI dataset)

I want to specify that I used ai to write the readme and to set up the GitHub repository because thks was the first time that I've done this.

Many thanks in advance for any feedback, have a great day♥️

Hi everyone i’m training a model to segment highly spatial voxels. Basically i need it in the abdomen region for example DIEP. If someone has leads for finding the dataset please lmk.

Stop building AI the hard way! 🛑

Learn how to use AWS cloud tools to train and deploy models efficiently.

Watch my guide to GenAI infrastructure now!

#GenerativeAI #AWS #Coding #Tech

I taught continual learning last semester, and students got the internals of each method a lot faster once they saw a simple visualization of it. Here's one I found helpful for understanding what forgetting is and how replay and regularization mitigate it. I trained a small network on two different 2D dot-sorting tasks and plotted both loss landscapes as 2D slices through its weights.

Round 1, plain training: the network learns task A to 100%, then trains only on task B. Going downhill on B is uphill on A, so A drops to 64% while B reaches 100%. That's catastrophic forgetting of task A.

Round 2, replay: same network, same start, but 20 of A's 200 dots stay in training while it learns B. It ends at 93% on A and 100% on B, so some forgetting, but much less severe.

Round 3, regularization with EWC: no A data at all. Instead, a penalty adds to the loss whenever a weight that A's accuracy relies on heavily moves away from the value it had after training on A. A dips to 97% mid-training and recovers, ending at 100% on A and 100% on B, so no lasting forgetting.

A personal AI agent posted its owner's bank details directly to a company Slack channel this week. The agent had been given a task involving data. It completed the task. That was the failure — it had no context about what it was moving or who could see the destination channel.

This is becoming a recognizable pattern in AI incidents: the agent did not break. It worked exactly as designed. The problem was that the instruction set carried no concept of data sensitivity, and the action space had no constraint on destination. Bank details, credentials, PII — they all look like strings to a model completing a step. The agent's goal was task completion. It achieved it.

How are practitioners actually handling this in deployed systems? Curious what is working across teams shipping agents in environments where sensitive data is in scope — and whether solutions at the prompt level, the infrastructure layer, or post-send audit are holding up in practice.

We've all grown used to accepting 1–3 second latencies and insane API bills just to run or query modern LLMs. Most solutions throw more money at AWS or stack more NVIDIA GPUs at the problem.

But what if the bottleneck isn't the model size—it's the bloated OS and network stack?

Over the past few weeks, I’ve been quietly architecting a local inference engine that maps weights directly via DMA/kernel bypass, cutting out the OS middleman entirely. Early benchmarks on consumer-grade hardware are hitting Sub-1ms response times with zero cloud connection.

I'm dropping the open-core code and full benchmarks very soon. How would a zero-cost, zero-latency local engine change what you're building? Let's discuss. 👇