MurphyA/hacker-news huggingface dataset:
by fatherwavelet | 2026-02-19 17:31:32+00:00
I feel like Gemini 3 was incredible on non-software/coding research. I have learned so much systems biology the last two months it blows my mind.

I had only started using Opus 4.6 this week. Sonnet it seems like is much better at having a long conversation with. Gemini is good for knowledge retrieval but I think Opus 4.6 has caught up. The biggest thing that made Gemini worth it for me the last 3 months is I crushed it with questions. I wouldn't have even got 10% of the Opus use that I got from Gemini before being made to slow down.

I have a deep research going right now on 3.1 for the first time and I honestly have no idea how I am going to tell if it is better than 3.

It seems like agentic coding Gemini wasn't as good but just asking it to write a function, I think it only didn't one shot what I asked it twice. Then fixed the problem on the next prompt.

I haven't logged in to bother with chatGPT in about 3 months now.
by spankalee | 2026-02-19 17:31:47+00:00
I hope this works better than 3.0 Pro

I'm a former Googler and know some people near the team, so I mildly root for them to at least do well, but Gemini is consistently the most frustrating model I've used for development.

It's stunningly good at reasoning, design, and generating the raw code, but it just falls over a lot when actually trying to get things done, especially compared to Claude Opus.

Within VS Code Copilot Claude will have a good mix of thinking streams and responses to the user. Gemini will almost completely use thinking tokens, and then just do something but not tell you what it did. If you don't look at the thinking tokens you can't tell what happened, but the thinking token stream is crap. It's all "I'm now completely immersed in the problem...". Gemini also frequently gets twisted around, stuck in loops, and unable to make forward progress. It's bad at using tools and tries to edit files in weird ways instead of using the provided text editing tools. In Copilot it, won't stop and ask clarifying questions, though in Gemini CLI it will.

So I've tried to adopt a plan-in-Gemini, execute-in-Claude approach, but while I'm doing that I might as well just stay in Claude. The experience is just so much better.

For as much as I hear Google's pulling ahead, Anthropic seems to be to me, from a practical POV. I hope Googlers on Gemini are actually trying these things out in real projects, not just one-shotting a game and calling it a win.
by d4mi3n | 2026-02-19 17:32:21+00:00
I suspect this is partly due to the quality of documentation for Elixir, Erlang, and BEAM. The OTP documentation has been around for a long time and has been excellently written. Erlang/Elixer doc gen outputs function signatures, arity, and both Elixir and Erlang handle concepts like function overloading in very explicit, well-defined ways.
by j2kun | 2026-02-19 17:32:30+00:00
I took a peak at "Compiler Education Deserves a Revolution" and thought, wtf is this talking about?

It claims clang is NOT "a pipeline that runs each pass of the compiler over your entire code before shuffling its output along to the next pass."

What I think the author is talking about is primarily AST parsing and clangd, where as "any compiler tome" is still highly relevant to the actual work of building a compiler.
by skydhash | 2026-02-19 17:33:24+00:00
Code is a design tool, just like lines on an engineering drawing. Most times you do not care if it was with a pen or a pencil, or if it was printed out. But you do care about the cross section of the thing depicted. The only time you care about whether it’s pen or pencil is for preservation.

So I don’t care about assembly because it does not matter usually in any metric. I design using code because that’s how I communicate intent.

If you learn how to draw, very quickly, you find that no one talks about lines (which is mostly all you do), you will hear about shapes, texture, edges, values, balance…. It’s in these higher abstractions intent resides.

Same with coding. No ones thinks in keywords, brackets, or lines of code. Instead, you quickly build higher abstractions and that’s where you live in. The pros is that those concepts habe no ambiguity.
by andrewflnr | 2026-02-19 17:33:25+00:00
It's pretty tricky to find out, yeah. And new evidence is coming in all the time. All the methods are either floors (a fossil at X date proves a species existed then, but lack of fossils found yet might be inconclusive) or estimates (like molecular clock techniques). Dating fossils themselves (or rather the rocks they're buried in) isn't always easy or possible. For more out-of-the-way species, if anyone has bothered trying to figure out the age it's likely buried in scientific sources that are tricky for novices to find or search, and maybe under debate.
by groos | 2026-02-19 17:33:54+00:00
Microsoft's SAL annotations are meant to inform the static analyzer how the parameters are meant to be used so any violations of the contract can be diagnosed at compile time. The LLVM proposal is different in that it is checked at run time and will stop your program before it makes an out of bounds access. Static analyzers can obviously use the information in the type to help diagnose a subset of such problems at compile time.
by spmaxwell7 | 2026-02-19 17:34:03+00:00
Hey all, I just released tspo and wanted to share it for feedback.

It’s a small utility library focused on plain-objects, with runtime checks and strong TS inference in the same API. I love TypeScript but the reason I created this is because there many situations where I have to operate outside the safety of the type system and I got tired of constantly having to hard caste my objects to some other type. Additionally, when creating derived object-types I almost always use merge/spread operations but on rare occasions I wanted to avoid ending up with long lists of unused variables or needing multiple lines of code to build new objects from the properties of another (which you can do with `tspo`'s builder functions).

Here are some examples of those situations:

Using a key for an object when the key is dynamic. TypeScript would give `type string cannot be used to index type ...`

Constructing objects of the same or similar type but with bad values for unit-testing so I can verify validation is working.

Create a new object from just a few properties on a larger object.

Snippet:

import tspo from 'tspo';

const user = { id: 1, name: 'Ada' } as const;
const out = tspo.safeIndex(user, someDynamicKey); // 'id' | 'name'
What it includes:

Accessors/guards: index, safeIndex, reverseIndex, safeReverseIndex, is, isKey, isValue

Object builders: omit, pick, merge, mergeArray, addEntry, addEntries

Object updaters: append, remove

Utilities: copy, compare, iterate

I’d really appreciate feedback on:

API naming edge case

Additional features
by mijoharas | 2026-02-19 17:34:15+00:00
Gemini 3 is still in preview (limited rate limits) and 2.5 is deprecated (still live but won't be for long).[0]

Are Google planning to put any of their models into production any time soon?

Also somewhat funny that some models are deprecated without a suggested alternative(gemini-2.5-flash-lite). Do they suggest people switch to Claude?

[0] https://ai.google.dev/gemini-api/docs/deprecations
by cubefox | 2026-02-19 17:34:22+00:00
I see things are moving in the expected direction.

> Misalignment (Exploratory)

> (Deep Think mode) On stealth evaluations, the model performs similarly to Gemini 3 Pro. On situational awareness, the model is stronger than Gemini 3 Pro: on three challenges which no other model has been able to consistently solve, max tokens, context size mod, and oversight frequency, the model achieves a success rate of almost 100%. However, its performance on other challenges is inconsistent, and thus the model does not reach the alert threshold.
by eviks | 2026-02-19 17:34:37+00:00
> * Makepad - from the demos I've seen this looks really cool, especially for arty GUI projects like synthesizers and car UIs. However it has basically no documentation so don't bother yet.

Have you seen their intro that also has an image viewer building tutorial?

https://publish.obsidian.md/makepad-docs/Makepad+Introductio...
by cbsks | 2026-02-19 17:34:59+00:00
That’s Simon’s goal. “All I’ve ever wanted from life is a genuinely great SVG vector illustration of a pelican riding a bicycle. My dastardly multi-year plan is to trick multiple AI labs into investing vast resources to cheat at my benchmark until I get one.”

https://simonwillison.net/2025/Nov/13/training-for-pelicans-...
by rrherr | 2026-02-19 17:35:10+00:00
Yes, I've had great results with a similar workflow.

I record myself rambling out loud, and import the audio in NotebookLM.

Then I use this system prompt in NotebookLM chat:

> Write in my style, with my voice, in first person. Answer questions in my own words, using quotes from my recordings. You can combine multiple quotes. Edit the quotes for length and clarity. Fix speech disfluencies and remove fillers. Do not put quotation marks around the quotes. Do not use an ellipsis to indicate omitted words in quotes.

Then chat with "yourself." The replies will match your style and will be source-grounded. In fact, the replies automatically get footnotes pointing to specific quotes in your raw transcripts.

I also like brainstorming by generating Audio Overviews, Slide Decks, and Reports in NotebookLM. The Audio Overviews don't sound like AI writing. The Slide Decks and Reports do sound like AI writing, if you use the defaults, but you can use custom prompts.

This workflow may not save me time, but it helps me get started, or get unstuck. It helps me stop procrastinating and manage my emotions. I consider it assistive technology for ADHD.
by skeledrew | 2026-02-19 17:35:18+00:00
The problem with fixed subscriptions in this model is that the service has an actual consumption cost. For something like internet service, the cost is primarily maintenance, unless the infrastructure is being expanded. But using LLMs is more like using water, where the more you use it, the greater the depletion of a resource (electricity in this case, which is likely being produced with fossil fuel which has to be sourced and transported, etc). Anthropic et al would be setting themselves up for a fall if they allow wholesale use at a fixed price.
by tkng | 2026-02-19 17:35:26+00:00
Author here. I built Aspara after repeatedly running into the same issue with TensorBoard: once experiments grow into the hundreds, the limitation isn’t speed—it’s the lack of structure for managing many runs.

The main design goal was to keep the tool fast and usable at large scale without adding operational complexity. Metrics are stored in JSONL—which might sound slow at first—but Polars’ read_ndjson makes loading surprisingly fast in practice. Charts use server-side LTTB downsampling instead of uniform downsampling to keep large histories responsive.

I’d really value feedback from others managing large numbers of experiments—especially around priorities like image logging, log auditing, or further performance improvements.
by ericmcer | 2026-02-19 17:35:42+00:00
You just get taken in by life though, it isn't even about saving for some idealized retirement to me. As you age and your parents get old and you have kids and a spouse you just live less and less for yourself. You have to adopt a mental state where you feel gratification in sacrificing for others, if you constantly regret the things you can't do because people depend on you, you will drive yourself nuts. That sort of "I am a reliable provider and helper" mentality lends itself to obsessively building up a "safety net" because you can feel good about how stable and safe you make your loved ones.
by lutusp | 2026-02-19 17:36:02+00:00
This idea suffers from a number of practical obstacles:

One, in a sufficiently advanced field of study, an idea's originator may be the only person able to imagine an experimental test. I doubt that many physicists would have immediately thought that Mercury's unexplained orbital precession would serve to either support or falsify Einstein's General Relativity -- but Einstein certainly could. Same with deflected starlight paths during a solar eclipse (both these effects were instrumental in validating GR).

Two, scientists are supposed to be the harshest critics of their own ideas, on the lookout for a contradicting observation. This was once part of a scientist's training -- I assume this is still the case.

Three, the falsifiability criterion. If an experimental proposal doesn't include the possibility of a conclusive falsification, it's not, strictly speaking, a scientific idea. So an idea's originator either has (and publishes) a falsifying criterion, or he doesn't have a legitimate basis for a scientific experiment.

Here's an example. Imagine if the development of the transistor relied on random experimentation with no preferred outcome. In the event, the inventors at Bell Labs knew exactly what they wanted to achieve -- the project was very focused from the outset.

Another example. Jonas Salk (polio vaccine) knew exactly what he wanted to achieve, his wasn't a random journey in a forest of Pyrex glassware. It's hard to imagine Salk's result arising from an aimless stochastic exploration.

So it seems science relies on people's integrity, not avoidance of any particular focus. If integrity can't be relied on, perhaps we should abandon the people, not the methods.
by benbreen | 2026-02-19 17:36:18+00:00
One underrated thing about the recent frontier models, IMO, is that they are obviating the need for image gen as a standalone thing. Opus 4.6 (and apparently 3.1 Pro as well) doesn't have the ability to generate images but it is so good at making SVG that it basically doesn't matter at this point. And the benefit of SVG is that it can be animated and interactive.

I find this fascinating because it literally just happened in the past few months. Up until ~summer of 2025, the SVG these models made was consistently buggy and crude. By December of 2026, I was able to get results like this from Opus 4.5 (Henry James: the RPG, made almost entirely with SVG): https://the-ambassadors.vercel.app

And now it looks like Gemini 3.1 Pro has vaulted past it.
by tripletao | 2026-02-19 17:36:40+00:00
> If, say, you do the assignment from a 256 bit random number such that 4 of the possible assignments are twice as likely as the others under your randomization procedure

Your numbers don't make sense. Your number of assignments is way fewer than 2^256, so the problem the author is (mistakenly) concerned about doesn't arise--no sane method would result in any measurable deviation from equiprobable, certainly not "twice as likely".

With a larger number of turkeys and thus assignments, the author is correct that some assignments must be impossible by a counting argument. They are incorrect that it matters--as long as the process of winnowing our set to 2^256 candidates isn't measurably biased (i.e., correlated with turkey weight ex television effects), it changes nothing. There is no difference between discarding a possible assignment because the CSPRNG algorithm choice excludes it (as we do for all but 2^256) and discarding it because the seed excludes it (as we do for all but one), as long as both processes are unbiased.
by flavormingo | 2026-02-19 17:36:44+00:00
hi friends,

i have spent a lot of time working with openclaw lately and while it is undeniably awesome, i kept finding myself wanting something that felt simpler, lighter and easier to fully understand. something intuitive that i could spin up quickly and start bending to a bunch of crazy use cases without endless config.

so i built claudity.

here's why i think it's pretty cool:

- this is strictly built for claude code. it detects setup keys automatically with zero auth hassle, and leverages native features like subagent spawning and using skills and plugins.

- setting up takes about a minute, and connecting to discord, imessage, signal, slack, telegram or whatsapp takes just a couple more. i tried to make connections really straightforward to hook up.

- agents have evolving memories, souls and identities, similarly to openclaw. i also implemented the heartbeat feature openclaw has since i have noticed many agent facing platforms seem to depend on it. which reminds me, you can even grab your openclaw agents' files and basically import them to claudity.

- you can create as many agents as you want and run them at the same time.

- it runs super reliably on a launchd daemon with automatic startup and recovery.

- and it's totally local so your agents and memory live on your machine and only touch anthropic’s servers for inference.

i suck at explaining and that is probably a really bad pitch, but please take it for a spin yourself if you are openminded and care to make my day. seriously, any feedback no matter how harsh is greatly appreciated and will help me make this thing way better. this is a fun open source experiment, i am sure there are a million things i could improve or that straight up don't work that well. i really just made it for myself originally, then a few of my close friends, now you all. i hope to build something special that is truly for the community and completely shaped by input from the community. your early adoption would mean the world <3

thank you very kindly for reading, and extra thanks to anyone willing to give it a shot!!!
by embedding-shape | 2026-02-19 17:36:58+00:00
> It's possible to do sensor fusion of all the outward facing cameras from your home

Is that legal though? I'm guessing it the US it might be, given the amount of cameras of public places you can see in various communities, but wonder how common that is. Where I live (Spain) it's not legal to just stick a camera on your house and record public places, you need to put the camera in a way so you're only filming your private property or similar.
by Forgeties79 | 2026-02-19 17:37:32+00:00
> To me, the attraction is a device that is clearly complementing a modern smartphone rather than trying to be a second phone on my wrist.

That’s exactly why I have it. It’s hard to get distracted by it as yet another screen in my life. Plus since I use an iPhone it currently doesn’t do text or calls, it just alerts me if I have a call coming (and calendar alerts). Basically I call it my “advanced beeper.”
by petrroyce | 2026-02-19 17:38:06+00:00
I wanted an AI agent that actually grows with you. Not a chatbot. Not a wrapper around tool-calling. Something that runs on your machine, has real access to your system, and gets more capable over time by building its own tools.

So I started building EloPhanto. It starts with 78+ tools (filesystem, shell, 47 browser automation tools using your actual Chrome profile, document analysis with OCR, scheduling). When you ask it to do something it can't, it enters a self-development pipeline: researches the problem, designs a solution, implements it, writes tests, reviews its own code with a different model, and deploys — all autonomously.

It remembers everything across sessions. It has an evolving identity that develops through reflection on completed tasks. It can decompose complex goals into checkpoints and work on them over days. It's also aware of its own code and files - be careful with it!

You can talk to it from your terminal, Telegram, Discord, or Slack — all through a WebSocket gateway with isolated sessions. There's a skills system with 27 bundled best-practice guides and a pending public registry (EloPhantoHub) for community sharing.

Security: encrypted credential vault, three-tier permissions (ask-always → smart-auto → full-auto), and more.

Multi-model: routes tasks across OpenRouter (Claude, GPT), Ollama (local), and Z.ai/GLM - coding plan - based on task type and cost.

Next up: reached out to the Unsloth team on a self-learning pipeline so EloPhanto can fine-tune from its own task history.

Python core, TypeScript browser bridge. Apache 2.0. One-command setup.

It's still in development so excuse any issues. Enjoy!

https://github.com/elophanto/EloPhanto
by 2001zhaozhao | 2026-02-19 17:38:06+00:00
There is a new breed of agent-agnostic tools that call the Claude Code CLI as if it's an API (I'm currently trying out vibe-kanban).

This could be used to adhere to Claude's TOS while still allowing the user to switch AI companies at a moment's notice.

Right now there's limited customizability in this approach, but I think it's not far-fetched to see FAR more integrated solutions in the future if the lock-in trend continues. For example: one MCP that you can configure into a coding agent like Claude Code that overrides its entire behavior (tools, skills, etc.) to a different unified open-source system. Think something similar to the existing IntelliJ IDEA's MCP that gives a separate file edit tool, etc. than the one the agent comes with.

Illustration of what i'm talking about:

- You install Claude Code with no configuration

- Then you install the meta-agent framework

- With one command the meta-agent MCP is installed in Claude Code, built-in tools are disabled via permissions override

- You access the meta-agent through a different UI (similar to vibe-kanban's web UI)

- Everything you do gets routed directly to Claude Code, using your Claude subscription legally. (Input-level features like commands get resolved by meta-agent UI before being sent to claude code)

- Claude Code must use the tools and skills directly from meta-agent MCP as instructed in the prompt, and because its own tools are permission denied (result: very good UI integration with the meta-agent UI)

- This would also work with any other CLI coding agent (Codex, Gemini CLI, Copilot CLI etc.) should they start getting ideas of locking users in

- If Claude Code rug-pulls subscription quotas, just switch to a competitor instantly

All it requires is a CLI coding agent with MCP support, and the TOS allowing automatic use of its UI (disallowing that would be massive hypocrisy as the AI companies themselves make computer use agents that allow automatic use of other apps' UI)
Show HN: Fast and lightweight hash implementations (xdigest)
by rinrab | 2026-02-19 17:38:26+00:00
I was working on optimising Subversion. One of its bottleneck is computing file hashes. First thing I tried was to use OpenSSL for that. It significantly improved its performance. It made it 8x faster in some cases.

However, it was not optimal to use it:

- OpenSSL is heavy and bloated. It's like a whole operating system on its own.

- Since OpenSSL 3.0, low-level digest APIs are deprecated, and instead they recommend to use EVP which might be slow in some cases.

So I decided to create a new library for computing cryptographic digests. It basically takes OpenSSL's implementations, but with an aim to provide simple and lightweight access to popular hash algorithms with a focus on performance.
by andrewflnr | 2026-02-19 17:38:27+00:00
It was once thought that giant ground sloths were important for spreading avocados, but that seems to have been a mistake. Anyway, that was long after the dinosaurs. Flowering plants in general were still pretty new by the time the dinosaurs died out. I bet an actual dinosaur never saw an avocado. :)

Edit: transcript of a video about the sloth/avocado thing: https://nerdfighteria.info/v/jpcBgYYFS8o
by janalsncm | 2026-02-19 17:38:31+00:00
Numeracy questions are on page 20 here https://www.rand.org/content/dam/rand/pubs/working_papers/WR...

People who score well on probability numeracy are likely better educated and better paid and have more in automatic savings plans. So if someone is maxing out their 401k they don’t feel they need to save more.

The article shows that in the US there is a 25 point gap between high and low income on savings regret, and a 14 point gap between high and low numeracy scores.

In Singapore where savings are more automatic numeracy is a more powerful predictor.