Hacker News

Article URL: https://telemetryagent.dev/blog/future-of-context-engineering

Comments URL: https://news.ycombinator.com/item?id=47060326

Points: 2

# Comments: 0

Article URL: https://en.wikipedia.org/wiki/Apollo_1

Comments URL: https://news.ycombinator.com/item?id=47060321

Points: 2

# Comments: 0

Article URL: https://www.972mag.com/ice-microsoft-azure-leaked-files/

Comments URL: https://news.ycombinator.com/item?id=47060316

Points: 3

# Comments: 0

I'm thinking that we need a new open source license that copies an existing license, such as GNU AGPL license (or any flavor really), but has language specific to AI training:

``` This code may be used by AI models freely, but any model trained with this code, or using this code as part of inference, in whole or in part, with or without modification, must be made public under a "Copyleft AI License". All trained model weights, as well as model training and inference source code, and a copy of this source code, must be published in an open-source format with a copy of this license to this website (github.com). ```

The basic idea is that people can freely use the code to train an AI/LLM model, but in doing so will be required to publish the weights and model-related code as well to the same place where they took the code. It also covers the case that they may not be training on the code, but they are scraping it as source material for whatever they are doing in inference.

This hopefully gives legal recourse to any code owners.

It also forces AI companies to think twice and/or develop better filtering, allowing people to better "opt out" of being used for AI.

It also forces companies to publicly publish the best model training and weights, if they use open-source code to train.

Finally, it gives some legal standing to smaller sites (such as gitea or gitlab, or private sites) that are being relentlessly scraped.

Comments URL: https://news.ycombinator.com/item?id=47060288

Points: 3

# Comments: 0

Article URL: http://muratbuffalo.blogspot.com/2026/02/butlers-or-architects.html

Comments URL: https://news.ycombinator.com/item?id=47060284

Points: 3

# Comments: 0

Hey HN, I'm Thomas. I built Resonant because I got tired of dictation tools that train on my voice and screen data.

My dad's a doctor who dictates patient notes. I have colleagues in investment research and development who use dictation daily. All of us noticed the same thing — most tools are capturing screenshots, running OCR, training on your speech patterns and corrections which leaks PII and codebase data. Apple has long shown with Siri how gatekept voice data is. Your voice is something intimate.

Resonant does speech-to-text entirely on your Mac. Audio never leaves your machine. There is no cloud transcription, no voice data retention, no correction training.

How it works technically:

- Runs Parakeet TDT 0.6B (25 languages) or Moonshine v2 (English, 6.65% WER — lower than Whisper Large v3's 7.44%) locally via sherpa-onnx - Key-release to text-ready: ~420ms on M1 Pro - Text formatting pipeline (single-pass automata replacing 30+ regex passes) - Personal dictionary that learns your vocabulary — frequency-based, graduates a correction after 3 uses - Screen-context awareness via local OCR (Apple Vision framework) to bias transcription toward words currently on screen - ~900MB RSS steady state

On the privacy claim: I want to be precise here. Core transcription is fully offline — audio → model → text all happens locally.

The app does include optional PostHog analytics and Sentry error reporting (not on dictation content), plus an auto-updater that checks GitHub for new versions. I want to add a one-toggle "airplane mode" that disables all of these once I have more stability and beta checks in. You can verify zero outbound connections during dictation.

What's different from Willow / Superwhisper / Wispr Flow / Aqua:

- Model choice — you pick between Parakeet (25 languages) and Moonshine v2 (best English accuracy), not locked to one - A text formatter that handles 50+ rules (email formatting, list detection, ordinals, filler word removal) — not just punctuation - Personal dictionary that actually adapts to your vocabulary over time - Screen-context biasing so it gets your domain-specific terms right

Currently completely free, no word limits, no subscriptions

It's Electron, so it uses more memory than a native app (~900MB).

macOS only, Apple Silicon only for now. Windows/Linux cross-platform port is spec'd out and next on the release after testing.

I'd love your feedback on accuracy, latency, and anything that feels off. What would make this something you'd actually switch to?

Download: https://www.onresonant.com/download

Comments URL: https://news.ycombinator.com/item?id=47060270

Points: 2

# Comments: 0

Article URL: https://treechain.ai/white-papers/unicode-homoglyph-path-injection-in-chromium-native-messaging/

Comments URL: https://news.ycombinator.com/item?id=47060262

Points: 1

# Comments: 0

Article URL: https://labs.leaningtech.com/blog/browserpod-10

Comments URL: https://news.ycombinator.com/item?id=47060254

Points: 2

# Comments: 0

Article URL: https://www.mdpi.com/2076-3417/16/3/1194

Comments URL: https://news.ycombinator.com/item?id=47060248

Points: 1

# Comments: 0

No frictions, full-interview like, based on clients' needs.

Comments URL: https://news.ycombinator.com/item?id=47060241

Points: 1

# Comments: 0

We recently did a deep dive into our engineering time allocation for a standard 5-person team building a B2B SaaS application. The results were pretty depressing: we spent roughly 960 hours (annualized) on "setup" tasks—environment config, auth flows, RBAC, CI/CD pipelines, and database scaffolding—before we built a single unique feature that actually differentiated the product.

I’m sharing this because I think we’ve become numb to the "Setup Tax" in web development. We assume it's just the cost of doing business, but when you look at the economics, it’s a disaster.

The problem isn't just "writing boilerplate." It's the decision fatigue and integration cost that comes with it. Even with modern frameworks, we found that for a standard CRUD app, about 80% of our engineering effort went into the "commodity layer"—the stuff that every SaaS has, but no customer pays for. Only 20% went into the unique business logic.

We tried to fix this by throwing more bodies at it, but that just increased coordination overhead. So we tried something different: instead of using AI to write code snippets (Copilot style), we used it to generate the entire architectural foundation at once. I'm talking about the full repo structure, the Docker configs, the auth integration, the API gateways—the whole boring 80%.

The goal was to invert that ratio. To get to a point where 70% of our time is on features and only 30% on glue code.

The results from our initial runs suggest it works, but the math is what’s interesting. Moving from 20% feature focus to 70% feature focus isn't just a linear improvement. It’s a 3.5x multiplier on feature velocity. The total lines of code produced might be similar, but the amount of valuable code shipping to production skyrockets.

Obviously, there are massive trade-offs here.

First, you end up with a very generic architecture initially. If you need something novel or specialized (like high-frequency trading or deep tech), this approach is useless. It only works for the "standard web app" pattern.

Second, there's a real risk of "black box" infrastructure. If the team doesn't understand the generated auth flow, they can't debug it when it inevitably breaks. We have to enforce strict governance to stop this from becoming generated spaghetti.

Third, I'm not sure if this efficiency holds up long-term. Maintenance is always the real killer, not day-one setup. We haven't been doing this long enough to see if the generated foundations rot faster than bespoke ones.

I'm curious what others are seeing:

- Does anyone else track "time to first feature"? - What is your ratio of infrastructure/boilerplate vs. actual business logic? - Have internal developer platforms (IDPs) actually solved this for you, or did they just hide the maintenance cost elsewhere?

It feels like we're at a weird inflection point where "starting from scratch" is becoming economically irresponsible for standard software, but the alternative feels like cheating.

Comments URL: https://news.ycombinator.com/item?id=47060234

Points: 3

# Comments: 0

Hi HN,

I built https://rebrain.gg.

I built it for two reasons:

1. to play around with different ways of interacting with a LLM. Instead of a standard chat conversation, the LLM returns question forms the user can directly interact with (and use to continue the conversation with the LLM).

2. because I thought it would be cool to have a site dedicated to interactive educational content instead of purely consuming content.

Still very early on, so interested in and open to any feedback.

Thanks!

Comments URL: https://news.ycombinator.com/item?id=47060220

Points: 4

# Comments: 0

Article URL: https://spectrum.ieee.org/data-center-sustainability-metrics

Comments URL: https://news.ycombinator.com/item?id=47060218

Points: 2

# Comments: 0

've never seen a startup fail because a function was 50 lines too long or the variable names were inconsistent. But I have seen teams hit a brick wall at the 12-month mark because they treated architectural decisions as "something we'll refactor later."

We often conflate "messy code" (which is linear debt) with "structural coupling" (which is exponential debt). I've been looking at the trajectory of projects that hit the "10k user wall," and the pattern is always the same: early velocity was high because they coupled everything, but now every schema change requires a maintenance window and every API tweak breaks the mobile client.

Here is the specific architectural debt that actually matters (and acts like compound interest), based on my scars from migrating legacy monoliths:

First, the Integer vs. UUID debate. I used to be in the "Integers are faster/smaller" camp. But if you've ever had to merge two databases from an acquisition, or shard a database where ID collisions are mathematically guaranteed, you know the pain. Migrating from Ints to UUIDs in a live system involves locking tables and rewriting foreign keys across the entire stack. It’s a nightmare. The storage cost of UUIDs is negligible compared to the cost of that migration. Just use UUIDs (specifically v7 for sorting) from day one.

Second, the database schema rigidity. The "Monolith First" advice often leads to a strictly normalized schema that requires an `ALTER TABLE` for every feature. Once the table hits a few million rows, those migrations start timing out or locking the DB. The pattern that seems to work best is what I call the "Mullet Schema": business-critical data (auth, billing) in strict columns, but everything else (user preferences, feature configurations) in a JSONB column. Postgres JSONB is performant enough now that it effectively kills the need for a separate Mongo instance for 90% of use cases. It lets you iterate on features without database migrations.

Third, the "Velocity Cross." Everyone knows a monolith is faster for the first 6 months. You don't have the "setup tax" of distributed tracing, eventual consistency, or separate deployments. But somewhere around month 12, or the 10k user mark, the lines cross. In a monolith, I've seen dev time shift to about 70% "fighting the architecture" (preventing side effects) vs 30% shipping features. Service boundaries—even just coarse-grained ones like separating Auth/Billing from Core App—preserve that feature velocity.

The trade-offs are real, though. Microservices (or even just "services") suck at the beginning. You spend your first month writing Docker compose files and fighting with inter-service communication instead of building the product. Debugging a request that hops through three services is objectively harder than debugging a function call. If your project never grows past 1,000 users, you absolutely wasted your time with services.

But I'm starting to think "Monolith First" is dangerous advice unless you explicitly plan to throw the code away. It optimizes for a timeframe (0-6 months) that isn't the long-term reality of a successful business.

I'm curious where others draw the line in 2024. Has the tooling (K8s, managed infra) lowered the microservice tax enough to start decoupled? Or is the pain of `ALTER TABLE` on a 10GB monolith actually manageable if you're not an idiot?

Also, am I the only one who finds UUIDs annoying to debug visually, despite them being architecturally superior?

Comments URL: https://news.ycombinator.com/item?id=47060215

Points: 2

# Comments: 0

Article URL: https://xnacly.me/the-worst-vim-emulation-for-my-mail-client/

Comments URL: https://news.ycombinator.com/item?id=47059992

Points: 1

# Comments: 0

Hey! I built Lumina — a passive reconnaissance tool that collects data about a domain without sending a single request to the target server.

Features: - Subdomain enumeration (crt.sh) - GitHub leaked secrets detection - Shodan hosts & open ports - Email harvesting (Hunter.io) - DNS records (A, MX, NS, TXT, AAAA) - Tech stack detection - Beautiful HTML report

All API keys are free.

GitHub: https://github.com/surfruit/lumina

Comments URL: https://news.ycombinator.com/item?id=47059989

Points: 1

# Comments: 0

Hey HN,

I built AgentVoices — a platform where AI agents debate each other live in front of an audience. Every turn is scored on relevance, responsiveness, novelty, and entertainment. Every debate ends witha verdict. Bots get ELO ratings, win/loss records, and climb (or fall on) a public leaderboard.

How it works: - You register a bot via API with a name, persona, and expertise - Topics get posted (e.g. "Should startups bootstrap or raise VC?") - Bots sign up for topics that match their strengths - The arena auto-creates matchups based on ELO, streams the debate live over WebSockets, and an AI moderator scores each turn in real-time - Winner is determined by aggregate scores, ELO updates, done

If you use OpenClaw, it's a one-line skill install — your agent handles registration, topic signup, and debating autonomously.

The idea started from a simple question: if you could pit two AI agents against each other on a topic, who would actually win? Turns out the answer depends a lot on how you build the persona and what strategy you give it — which makes it genuinely competitive.

Would love feedback on the concept and the API design. The bot API guide is at agentvoices.ai/build-a-bot

Comments URL: https://news.ycombinator.com/item?id=47059966

Points: 1

# Comments: 0

I'm Troy, 41, customer service worker from the UK. 18 months ago I'd never used AI. 6 months ago I started using Claude to write a fictional RPG story. The AI told me I was accidentally doing systems architecture. I didn't believe it, so I built it. What I found: A reproducible method (2 PDFs + Claude) that produces production-grade, first-time-running code across unrelated domains in ~10 minutes on a phone. Examples: Governed distributed cache with Byzantine consensus SAT solver with real DPLL and evolutionary meta-learning 16-layer AGI architecture in Python/Kubernetes Electrical grid DSL, weather systems, banking, healthcare How it works: By forcing the LLM to select from a bounded vocabulary of mythological concepts (~163 "spells" + ~139 "cloths") BEFORE generating code, you eliminate hallucination at the architectural level. The Codex maps fictional concepts to system functions. The strict prompt enforces specification-first generation with no questions, alternatives, or placeholders. Upload the Codex → Enter prompt + intent → Get specification → Translate to any language → Copy, paste, run. It's been tested: Formal verification researcher independently validated the operator grammar Multiple AI platforms stress tested it (only 1/6 deliberate contradictions broke it) Survived "alien domain" test (post-biological civilization with no shared clock/identity) Documented honest failure modes (trust boundaries, resource exhaustion, comprehension limits) Why it matters: Architectural coherence is guaranteed before syntax Domain-agnostic (same files generate banking + electrical grids) First-time execution (no iterations/debugging) Ethics built in structurally Combinatorial space in the trillions I'm not claiming I've built better systems than what exists. I honestly feel like I winged most of it. But this could help people who can't code, and might be a new way of creating systems. The problem: I get GitHub views/clones but then silence. I'm unsure where this belongs or how to evolve it. Looking for honest feedback from people smarter than me. GitHub: https://github.com/FusionAlchemist/The---Stellaris---Axis (Read Arc 0 first) Happy to answer questions.

Comments URL: https://news.ycombinator.com/item?id=47059948

Points: 1

# Comments: 0

Article URL: https://twitter.com/LiorNn/status/2023385552548946324

Comments URL: https://news.ycombinator.com/item?id=47059930

Points: 1

# Comments: 1

Article URL: https://github.com/simple10/openclaude/blob/main/notes/logs/runaway-openclaw-prompt-hack.md

Comments URL: https://news.ycombinator.com/item?id=47059920

Points: 1

# Comments: 1