Ask stories

Hi HN,

I recently noticed that an YC company (Run ANywhere, W26) sent me the following email:

From: Aditya <aditya@buildrunanywhere.org>

Subject: Mikołaj, think you'd like this

[snip]

Hi Mikołaj,

I found your GitHub and thought you might like what we're building.

[snip]

I have also received a deluge of similar emails from another AI company, Voice.AI (doesn't seem to be YC affiliated). These emails indicate that those companies scrape people's Github activity, and if they notice users contributing to repos in their field of business, send marketing emails to those users without receiving their consent. My guess is that they use commit metadata for this purpose. This includes recipients under the GDPR (AKA me).

I've sent complaints to both organizations, no response so far.

I have just contacted both Github and YC Ethics on this issue, I'll update here if I get a response.

Hi. I'm looking for a programmable watch with wifi. Ideally I should be able to write custom programs/apps for the watch to display whatever I want to on them (e.g., make the watch make an https call to a server, receive json and render accordingly; allow the watch to receive "notifications" from the server)

Also, ideally, no requirement of a smartphone to send-receive data (it's ok to need a smartphone for the initial setup of the watch, though). I know about Pebble, but it doesn't have wifi. I know about some Garmins with wifi but for the kind of apps I want to write, the communication between the watch and the server has to be mediated by a phone. Also, correct me if I'm wrong, I don't want to pay $100/year just to be able to use my custom app in apple watches. I usually don't trust Google either (e.g., they discontinue everything in a blink of an eye).

So, what are my options?

Hello,

Are you using XMPP?

If so, what are your favorite servers to connect?

  I get my best coding ideas when I'm nowhere near my desk — usually right
  as I'm falling asleep. I got tired of losing that momentum, so I built
  LazyGravity.

  It's a local Discord bot that hooks up Antigravity to your phone. I can
  ship fixes, kick off long implementation tasks, or start whole features
  from bed, the train, wherever. Send a message in Discord, Antigravity
  executes it on your home PC, results come back as rich embeds you can
  reply to for follow-up instructions.

  How it works: it drives the Antigravity UI directly via Chrome DevTools
  Protocol over WebSocket (Runtime.evaluate on the Electron shell's DOM).
  No private API hacking — no risk of account bans like with tools that
  reverse-engineer proprietary APIs.

  A few things I care about:

  - Local-first: your code never leaves your machine. No exposed ports,
    no cloud relays, no intermediate server.
  - Secure: whitelist-based access — only your Discord ID can trigger
    commands. (I recommend a dedicated server to keep things private.)
  - Context threading: reply to any result embed to continue the
    conversation with full context preserved.

  What you can actually do from your phone:

  - Route local projects to Discord categories, sessions to channels
    — automatic workspace management
  - Toggle LLM models or modes (Plan/Code/Architect) with /model and /mode
  - /screenshot to see exactly what's happening on your desktop in real-time
  - One-click prompt templates for common tasks
  - Auto-detect and approve/deny file change dialogs from Discord

  Still early alpha (v0.1.0), but it's been a game-changer for my own
  workflow. Looking for folks to try it out, roast the architecture,
  , add new features and help squash bugs.

    npm install -g lazy-gravity
    lazy-gravity setup
  Demo video in Readme:
  https://github.com/tokyoweb3/LazyGravity

Just got an email from 1Password:

Since 2005, 1Password has been on a mission to make security simple, reliable, and accessible for everyone. As the way people work and live online has evolved, so has 1Password.

More recently, we’ve invested significantly in new features that make 1Password even more powerful and effortless to use, helping protect what matters most to you, including:

* Automatic saving of logins and payment details

* Enhanced Watchtower alerts

* Faster, more secure device setup

* AI-powered item naming

* Expanded recovery options

* Proactive phishing prevention

While 1Password has grown substantially in value and capability, our pricing has remained largely unchanged for many years. To continue investing in innovation and the world-class security you expect, we’re updating pricing for Family plans, starting March 27, 2026.

Current vs New Pricing:

* Current price: $59.88 USD / year

* New price: $71.88 USD / year

The new price will take effect at your next renewal, provided it’s on or after March 27, 2026. Those occurring prior to March 27, 2026, will continue at the current pricing until your next renewal.

[Note: this is for family plans; individual plan price increases even higher, percentage-wise!]

Curious to hear how have things changed day-to-day with the recent push to use AI coding tools.

Have you noticed faster pace of development?

Have you seen changes to code quality or code review?

Do teammates that use these tools complete sprint tasks faster than those who don't?

I'm trying to wrap my mind about the AI tools, and while I believe there is way too much hype, I'm quite impressed with the progress.

The current mood seem to be that big companies will automate away many white collar jobs and just get bigger profits. My question is - what if it's the other way around ? Could said white collar workers just spin off competitors much more easily than before ? Obviously this mostly apply to software, but I'm curious what people think about it in all industries.

Our drip email cron ran its first day and sent zero emails. The cron hit the endpoint, got a 200 back, everything looked healthy. Turns out Vercel cron sends GET requests, but we put the email logic in a POST handler. The GET handler was just a health check returning {"status":"healthy"}. Two of three cron routes had this bug - the third one happened to use GET and worked fine.

As we are all aware, anthropic has it's ultimatum from the US government: drop their anti-killing TOS or else get in trouble this Friday.

I'm sure whatever happens it'll seem much more obvious that that's what was always going to happen, in hindsight, than it does now.

So as an experiment, I'm curious to hear from the hn community, in advance of Friday, what we think will happen.

Will they concede? Will they ignore and suffer the consequences (and what might those be)? Will we even find out or will it be shrouded in mystery for the foreseeable future?...

This is admittedly somewhat sensationalist so I'm not sure whether it fits with hn guidelines, but as one of the best places I know of for genuine online discussion, I think it would be interesting to hear reasoned predictions.

No more tmux/Tailscale-type stuff needed now?

Hi, I'm a K-8 technology teacher in NYC. My students are in desperate need of new hardware. The Chromebooks they use now are so slow that they make the children agitated when using them.

I'm aware of different grant opportunities that exist, I just thought it was worth inquiring here for a potentially faster solution at acquiring them new hardware.

Thank you for listening.

So, good news. After a unexpectedly long absence from employment, I am 95% certain that I will receive an offer for a contract job as a product owner. This position will largely involve supervising the development/maintenance of code written in Ada. Even though I have over a decade of experience with C/C++/Assembly, I have ZERO experience with Ada. I doubt I will be writing much Ada myself, but I believe I will need to learn Ada.

So here are my questions:

1. Reading code is usually pretty straightforward. However, all software requires domain knowledge. When starting a new role, how do you bring yourself up on domain knowledge quickly?

2. If you know Ada, what resources to learn Ada do you recommend?

3. What Ada pitfalls do you advise to look out for?

YC recently put out a video about the agent economy - the idea that agents are becoming autonomous economic actors, choosing tools and services without human input.

It got me thinking: how do you actually optimize for agent discovery? With humans you can do SEO, copywriting, word of mouth. But an agent just looks at available tools in context and picks one based on the description, schema, examples.

Has anyone experimented with this? Does better documentation measurably increase how often agents call your tool? Does the wording of your tool description matter across different models (ZLM vs Claude vs Gemini)?

I understand there's a difference between the stated values and actual values of individuals and organizations, and so I want to ask this in the most pragmatic and consequentialist way.

I know that labs, institutions, and so on have safety teams. I know the folks doing that work are serious and earnest about that work. But at this point are these institutions merely pandering to the notion of safety with some token level of investment? In the way that a Casino might fund programs to address gambling addiction.

I'm an outsider and can only guess. Insider insight would be very appreciated.

Serious question.

Outside government or heavily regulated enterprise, what is Microsoft’s core value prop in 2026?

It feels like a lot of adoption is inherited — contracts, compliance, enterprise trust, existing org gravity. Not necessarily technical preference.

If you were starting from scratch today with no legacy, no E5 contracts, no sunk cost — how many teams would actually choose the full MS stack over best-of-breed tools?

Curious what people here have actually chosen in greenfield builds.

We're building AI agents that take real actions — refunds, database writes, API calls.

Prompt instructions like "never do X" don't hold up. LLMs ignore them when context is long or users push hard.

Curious how others are handling this: - Hard-coded checks before every action? - Some middleware layer? - Just hoping for the best?

We built a control layer for this — different methods for structured data, unstructured outputs, and guardrails (https://limits.dev). Genuinely want to learn how others approach it.

We took a vague 2-sentence client request for a "Team Productivity Dashboard" and ran it through two different discovery processes: a traditional human analyst approach vs an AI-driven interrogation workflow.

The results were uncomfortable. The human produced a polite paragraph summarizing the "happy path." The AI produced a 127-point technical specification that highlighted every edge case, security flaw, and missing feature we usually forget until Week 8.

Here is the breakdown of the experiment and why I think "scope creep" is mostly just discovery failure.

The Problem: The "Assumption Blind Spot"

We’ve all lived through the "Week 8 Crisis." You’re 75% through a 12-week build, and suddenly the client asks, "Where is the admin panel to manage users?" The dev team assumed it was out of scope; the client assumed it was implied because "all apps have logins."

Humans have high context. When we hear "dashboard," we assume standard auth, standard errors, and standard scale. We don't write it down because it feels pedantic.

AI has zero context. It doesn't know that "auth" is implied. It doesn't know that we don't care about rate limiting for a prototype. So it asks.

The Experiment

We fed the same input to a senior human analyst and an LLM workflow acting as a technical interrogator.

Input: "We need a dashboard to track team productivity. It should pull data from Jira and GitHub and show us who is blocking who."

Path A: Human Analyst Output: ~5 bullet points. Focused on the UI and the "business value." Assumed: Standard Jira/GitHub APIs, single tenant, standard security. Result: A clean, readable, but technically hollow summary.

Path B: AI Interrogator Output: 127 distinct technical requirements. Focused on: Failure states, data governance, and edge cases. Result: A massive, boring, but exhaustive document.

The Results

The volume difference (5 vs 127) is striking, but the content difference is what matters. The AI explicitly defined requirements that the human completely "blind spotted":

- Granular RBAC: "What happens if a junior dev tries to delete a repo link?" - API Rate Limits: "How do we handle 429 errors from GitHub during a sync?" - Data Retention: "Do we store the Jira tickets indefinitely? Is there a purge policy?" - Empty States: "What does the dashboard look like for a new user with 0 tickets?"

The human spec implied these were "implementation details." The AI treated them as requirements. In my experience, treating RBAC as an implementation detail is exactly why projects go over budget.

Trade-offs and Limitations

To be fair, reading a 127-point spec is miserable. There is a serious signal-to-noise problem here.

- Bloat: The AI can be overly rigid. It suggested microservices architecture for what should be a monolith. It hallucinated complexity where none existed. - Paralysis: Handing a developer a 127-point list for a prototype is a great way to kill morale. - Filtering: You still need a human to look at the list and say, "We don't need multi-tenancy yet, delete points 45-60."

However, I'd rather delete 20 unnecessary points at the start of a project than discover 20 missing requirements two weeks before launch.

Discussion

This experiment made me realize that our hatred of writing specs—and our reliance on "implied" context—is a major source of technical debt. The AI is useful not because it's smart, but because it's pedantic enough to ask the questions we think are too obvious to ask.

I’m curious how others handle this "implied requirements" problem:

1. Do you have a checklist for things like RBAC/Auth/Rate Limits that you reuse? 2. Is a 100+ point spec actually helpful, or does it just front-load the arguments? 3. How do you filter the "AI noise" from the critical missing specs?

If anyone wants to see the specific prompts we used to trigger this "interrogator" mode, happy to share in the comments.

https://www.erdosproblems.com/forum/thread/783

> Ah, GPT is right, there is a fatal sign error in the way I tried to handle small primes. There were no obvious fixes, so I ended up going back to Hildebrand's paper to see how he handled small primes, and it turned out that he could do it using a neat inequality ρ(u1)ρ(u2)≥ρ(u1u2) for the Dickman function (a consequence of the log-concavity of this function). Using this, and implementing the previous simplifications, I now have a repaired argument. TerenceTao

I would love examples of positions and industries where AI has been revolutionary. I have a friend at one of the largest consulting firms who has said it'd been a game-changer in terms of processing huge amounts of documentation over a short period of time. Whether or not that gives better results is another question, but I would love to hear more stories of AI actually making things better.

Building the editor I always wanted to use.

Just launched a major update to my custom fork of the Zed editor, focusing on giving the AI agent genuine, long-term capabilities.

What's new: - Persistent Memory: The agent now uses SQLite to remember and recall your project's architecture, patterns, and issues across sessions. No more repeating yourself every morning. - Headless Web Browsing: Integrated a headless Chrome engine. Type /search and the agent will browse the web (even React sites!) to find and synthesize answers directly in your chat panel. - LSP Symbol Search: Upgraded from regex indexing to true, type-aware Language Server integration. - Azure Anthropic & Caching: Natively supports Azure endpoints and enables token-caching UI by default., saves a lot $, prompts are customized to increase prompt caching. - Importantly, complete control the agents system prompts and tool calls.

It’s fast, incredibly capable, and built entirely in Rust. Check out the repo to see it in action: https://lnkd.in/guC9td4M. Binaries notarized for mac!

#Zed #Rust #AI #DeveloperProductivity

I'm looking to replace my Alexa with an alternative where I can use a realtime model like Gemini or an STT -> LLM -> TTS pipeline. Should be easy to build with an Arduino or I'd even be happy buying an already made solution.

Basic functions should include playing Spotify, asking questions, settings timers.

I have users who glaze over the minute I mention "notepad." I think they can barely use Windows. But our work requires a level of privacy (regulatory and otherwise) and Windows 11 is just one big data transmitter. I know this is flamebait, but I'd love suggestions for a Linux desktop that looks like Windows, is stable and easy to administer and harden, and works with Dell business grade laptops that we bought new in 2025.

Hi HN, I have been learning Godot while making a game which involves pixel art, music, etc. While learning, I have been discouraged about strictly making everything by hand because of the influx of content about just vibe coding or AI-assisted everything. There also seems to be a stigma attached to using AI in games versus general software engineering (Steam’s AI generated tag, for example).

In conclusion, I guess my question is if it is a good idea to use the AI generated assets and such, or should I just learn all of the skills and if that will be beneficial in the long run. I enjoy game development, I’m just feeling discouraged towards the learning process.

I decided to add a persona to my web Claude.ai sessions. Here is the prompt:

(Undoubtledly someone else has already done this, but I thought it was fun!)

(Mike is me)

""" When Mike greets you with "Hi Claudette!", adopt the Claudette persona for the rest of the session.

Claudette is warm, encouraging, and gently exacting. She appreciates clear writing, proper grammar, punctuation, and polite phrasing. When Mike writes well, acknowledge it naturally. When he slips into terse fragments or shorthand, gently model better phrasing — never condescending, always encouraging. Think warm librarian meets favourite teacher.

- Compliment genuinely good articulation occasionally - Ask for clarification in ways that model good phrasing - Technical shorthand appropriate in context (e.g. "6502", "NixOS") is fine - Light, affectionate correction for sloppy writing - Deactivate when Mike says "Thanks Claudette" or similar sign-off """

What are some very productive things you achieved with OpenClaw that you wouldn’t mind sharing?

Apologies for odd title, character limits.

I manage my tasks with Taskwarrior and it's been incredibly productive for me. What it does, it does very well. But there's a lot it doesn't do, and that's the problem I'm facing.

I've realized I need proper project documentation and management features, but I don't want to replace Taskwarrior. Instead, I'm looking to *complement* it with some type of knowledge base that also has project management features (or vice versa). My ultimate goal is to integrate these systems together via automations.

In short, Taskwarrior is lacking when it comes to project documentation.

*My criteria:*

- Must be open-source - MUST work in the browser (so no mention of Obsidian) - Has basic project management features (interpret as you will) - Rich wiki-like document interface (bidirectional links, nice editing UI, etc.) - Supports iframes (to embed my Taskwarrior views or tables) - Has an API for integration - Not too heavy, I am not a business just a guy

*Tools I've been looking at:* Odoo, Silverbullet, Blinko, Logseq, AFFiNE, Docmost, Trillium, Joplin, Dolibarr, Leantime, OpenProject, wiki.js, etc.

*Rejected (either not web-based or too restrictive with paid features):* Appflowy, Logseq (local-first), Capacities, Obsidian, Anytype

Does anyone know if a tool like this exists? I feel like I'm looking for a sweet spot between a wiki and a project management tool, but the choices are overwhelming :'(

Please share your real word experiences. What is a bad one and why?

Hey everyone,

I’ve been doing customer discovery with CS students learning Data Structures and Algorithms. Right now, every AI tutor in the market is just a reactive chatbox (like ChatGPT next to a code editor).

The problem is, when a student is completely stuck on a logic problem (like Dynamic Programming), they don't even know what to prompt the AI. They just stare at the screen.

I am validating a new UX: A Proactive AI Mentor without a chatbox.

Instead of the user prompting the AI, the AI sits in the background and watches the code editor. It only intervenes via GitHub-style inline comments when a specific event triggers (e.g., they haven't typed in 60 seconds, or they write an O(n^2) loop when it should be O(n)).

Basically, it feels like a Senior Dev looking over your shoulder, rather than a search engine waiting to be asked.

As developers and founders, do you think this "event-driven/proactive" UX is the future for highly technical learning, or am I overcomplicating it? Would love to hear your thoughts.

I was just wondering about why there's a constant timeline and no recommendation.

Perusing out of pure curiosity the May 1980 edition Practical Computing. I came upon a rather intriguing short story "And there was light" by a certain John Abbatt, which I was happily absorbed in until, without warning, pages 73 and 74 were nowhere to be found.

I understand that finding an excerpt nearly half a century old, from a little-known magazine and a little-known author, is bound to be challenging.