ashwindharne

I believe it's calculated based on voting equity, of which Sergey owns significantly more than 230b.

Same here, this is an incredibly useful thing to have in the toolkit

Looks great -- always wished the admin panel came with more configurable bells and whistles. I've been exploring Quarkus recently (https://quarkus.io/), and it has a Dev UI with a similar extensible "panels" pattern. It's a bit different than Django since it's not for running in prod, but nonetheless it's pretty helpful.

sort of a tangent, but quarkus also has a concept of "dev services" that are monitorable via the dev UI. It uses Testcontainers to start and autowire runtime deps (postgres, redis, keycloak, etc.). Pretty pleasant experience to get the whole stack spun up and observable alongside the dev server.

I'm building something similar, but as an Excel add-in instead of a standalone product.

In real use-cases, it seems that by far the hardest part is figuring out the right representation for a spreadsheet workbook and the right primitives for the agent to be able to navigate it adeptly and cost-effectively; structure is incredibly variable and the data just compresses rather poorly (values, formulas, formatting, charts, pivots, etc.).

Great stuff though, think we'll see a lot of movement in the space in the coming years!

I'm always a little hesitant to use D1 due to some of these constraints. I know I may not ever hit 10GB for some of my side projects so I just neglect sharding, but also it unsettles me that it's a hard cap.

I get this a lot too, have made most of the Gemini models essentially unusable for agent-esque tasks. I tested with 2.5 pro and it still sometimes devolved into random gibberish pretty frequently.

I've found that this phenomenon exacerbates inequality too:

If you attend a well-known college that bigco's hire from frequently, there's a lot of knowledge floating around about interview prep, hiring schedules, which companies pay the best, etc. Clubs host "interview prep workshops" where they'd teach the subject matter of interviews, host events(hackathons, case competitions, etc.) to help you bolster your resume for applying to these bigco's. So just by attending a better/fancier school, you'd have pretty decent odds of eventually getting a job at one of these prestigious places.

If you were to attend a less prestigious school, regardless of your aptitude or capability, the information asymmetry is so bad that you'll never learn of the prerequisites for even being considered for some of these roles. Not many upperclassmen will have interned at fancy employers, so they won't be there to help you drill dynamic programming/black-scholes/lbo models, and won't tell you that you need to have your applications prepped by a certain date, and won't tell you that you should be working on side projects/clubs, etc.

I suppose that the apprenticeship model biases towards people that already have connections, so perhaps inequality was already bad, whereas now we just have an information asymmetry that's more easily solvable.

I went to a basement party/rave recently where the DJ was live-coding strudel, was incredibly cool to see in person. people would watch them type out new lines in anticipation of a beat drop

Pretty cool to see this post, I had no idea where to find more info about it!

I think performance takes a hit due to WASM, and I imagine pricing is worse at big qps numbers (where you can saturate instances), but I've found that deploying on CF workers is great for little-to-no devops burden. Scales up/down arbitrarily, pretty reasonable set of managed services, no cold start times to deal with, etc.

Only issue is that some of the managed services are still pretty half-baked, and introduce insane latency into things that should not be slow. KV checks/DB queries through their services can be double-to-triple digit ms latencies depending on configs.

HN's AI hate-boner has always been a bit off-putting to me. This is a technology forum, and it's pretty much the biggest advance in recent technology that has potential implications for all of our lives. I definitely also get AI-fatigue, but it's no mystery why there's a preponderance of content about LLMs, diffusion models, self-driving cars, etc.

YC's goals are to manage risk and to make money, and new tech like this is almost certain to make someone a lot of money. All these YC companies are just different random initializations of potential ways that this new generation of AI can affect the world. It's a given that most startups of this breed will fizzle out with no impact, but I imagine that a few of them will actually change how something is done (and make a lot of money in the meantime).

Google seems to be the main foundation model provider that's really focusing on the latency/TPS/cost dimensions. Anthropic/OpenAI are really making strides in model intelligence, but underneath some critical threshold of performance, the really long thinking times make workflows feel a lot worse in collaboration-style tools, vs a much snappier but slightly less intelligent model.

It's a delicate balance, because these Gemini models sometimes feel downright lobotomized compared to claude or gpt-5.

This post has the same issues as NotebookLM for me -- overdesigned, overengineered for what at its core is a simple and valuable UX.

NotebookLM: obviously useful, but I just wanna select some files and chat w/ them or have them summarized for me. It's got low info density, way too many cards/buttons/sections/icons, and it makes the core UX really difficult for me to navigate.

This post: I wanted to know what cool thoughts he had while designing it. Instead I get some weird scrolljacking, image carousels, unnecessary visual hierarchy, cards galore, etc.

Not trying to be too negative, it's slick and all but it just gets in the way for me instead of disappearing.

I used ANTLR recently to prototype a spreadsheet formula language -- backend was JVM so it was reasonably easy and batteries-included.

I always find that my regular crud apps kind of grow into something not-so-cruddy due to a single feature (realtime communication, bursty usage profile, large batch jobs to precompute something to expensive to do at request time) and the architecture just explodes from there. s

also, it always feels like I need a second instance at the very least for redundancy, but then we have to ensure they're stateless and that batch jobs are sharded across them (or only run on one), and again we hit an architecture explosion. Wish that I was more comfortable just dropping a single spring boot instance on a vm and calling it a day; spring boot has a lot of bells and whistles and you can get pretty far without the architecture explosion but it is almost inevitable

Should the other players not have also raised VC money if it was such a differentiating advantage? Perhaps they should have sold even more equity than Figma did and raised more money if that would have been the difference maker.

KV caching is priced and managed quite differently between providers as well. Seeing as it becomes a huge chunk of the actual tokens used, wondering if there's an easy way to compare across providers.

Gemini models seem to be much less predictable than Claude -- I used them initially on my Excel 'agent' b/c of the large context windows (spreadsheets are a lot of tokens) but Gemini (2.5 Pro AND Flash) would go rogue pretty regularly. It might start dumping the input sheet contents into the output formatted oddly, output unrelated XML tags that I didn't ask for, etc.

As soon as I switched to Anthropic models I saw a step-change in reliability. Changing tool definitions/system prompts actually has the intended effect more often than not, and it almost never goes completely off the rails in the same way.

'Agents' are just a design pattern for applications that leverage recent proper scientific breakthroughs. We now have models that are increasingly capable of reading arbitrary text and outputting valid json/xml. It seems like if we're careful about what text we feed them and what json/xml we ask for, we can get them to string together meaningful workflows and operations.

Obviously, this is working better in some problem spaces than others; seems to mainly depend on how in-distribution the data domain is to the LLM's training set. Choices about context selection and the API surface exposed in function calls seem to have a large effect on how well these models can do useful work as well.

It's all unstructured text (title, company, company size, experience, skills, raw text, etc.) and LLMs are pretty bad at assigning numerical scores in a vacuum. To make it work, we'd have to provide a representative set of examples, break scoring down by specific field, etc.

Kind of a lot of work compared to just dumping the text of 2 profiles into a context window along with a vague description of what I want, and having the LLM make the binary judgment.

Cool stuff! We use a similar process internally to rerank and filter our cold outbound lists. We just use an off-the-shelf model as the judge, give it a custom criteria, and let it run until some set number of iterations. It's helped narrow down wide searches to the maximally relevant set of people (few thousand medium-bad matches to few hundred good matches)

It's not cheap and it's not fast, but it definitely works pretty well!

I do find that having inference happen ~50% faster is much more valuable to my workflow than a single digit accuracy increase. If I'm going to have to check that the changes are correct anyways, getting more iterations in faster feels much better than incremental accuracy.

There's definitely a tipping point though. If the accuracy gains are so high that I can check its work less carefully or less often, the benefits of inference speed are effectively nil.

Not sure how active it is outside large US cities but I've been using Beli (https://beliapp.com/) for the past couple years. It's essentially friends stack-ranking restaurants they've been to, which is useful because I can adjust for their biases -- they care varying amounts about service, cleanliness, authenticity, creativity, ambiance, etc. I regularly find new spots through friends and can decide if I trust their taste enough to order/check it out in person.

Only downside is it's pretty limited to the yuppie-foodie crowd - like in NYC, once you venture into deeper Brooklyn/Queens/The Bronx, you won't find much on there.

I've been using Temporal recently for some long-running multi-step AI workflows -- helps me get around API flakiness, manage rate limits for hosted models, and manage load on local models. It's pretty cool to write workers in different languages and run them on different infra and have them all orchestrate together nicely. How does DBOS compare -- what are the core differences?

From what I can tell, the programming model seems to be pretty similar but DBOS doesn't require a centralized workflow server, just serverless functions?

Secondhand shopping and stores

Trying to build something for businesses like thrift stores, vintage stores, secondhand stores, used furniture, consignment, etc. I started working at a vintage shop a few months ago after leaving my SWE job, and it's a pretty analog industry. No updated inventory, digital presence, business intelligence, etc. (not for lack of usefulness or lack of trying, just because digitizing hundreds or thousands of unique one-off items is really labor intensive and not ergonomic on existing tools). Hoping to build something purpose built for the use case that can also make shopping secondhand more accessible to end consumers.

Feel like the social stigma against "used goods" is dissipating, and shopping secondhand/vintage is seen as a viable or even preferable option b/c of cost, uniqueness, cyclical nature of trends, or sustainability efforts.

If anyone has any thoughts or tips, I'd love to hear them!