maherbeg

Happy to chat about this, but we use the AWS secrets manager flowing into External Secrets Operator to generate a pgdog_users.toml. We then kick off a workflow to refresh things, but our rate of change here is much smaller than a super dynamic multi-tenant system.

You could also build a watcher side car that watches for changes of the pgdog_users.toml and have pgdog refresh itself then too with this combination. We thought about that but prefer to control the reloads for our needs.

iOS 27 supports devices all the way down to the iPhone 11, so I think they're doing pretty well here.

Great post! There are some neat tricks around completion initing that I'll have to grab. I use fish shell and have done a bunch of optimization around async git statuses too.

for sure! but there are lots of incremental shareable primitives that could help. I think about go's built in testing tools that can get extended as an example

Very happy for them, they made excellent tools and I hope they can continue their work!

I do believe though that these tools (formatting, linting etc.) should be built into the language like Go, and I really hope the Node team can just absorb the best ideas and make solid primitives that can be built on top of as the ecosystem evolves (think golang's http interfaces, or test interfaces)

In addition to this, the labs are all building managed cloud agents, where they can tune better models and better harnesses. If you want the best performance, you'll eventually have to use their platform with their secret alpha baked in.

There will always be a gap, but what's interesting is that because new models are constantly coming out, we as an industry never spend any time extracting the maximal value out of an existing model. What if there are techniques, and harness workflows that could be optimized for a singular model end to end? How far can that push the state of the art.

An example is https://blog.can.ac/2026/02/12/the-harness-problem/ for just improving edits.

Or if we could really steer these open source models using well structured plans, could we spend more time planning into a specific way and kick off the build over night (a la the night shift https://jamon.dev/night-shift)

This is so sick. I'm really curious to see what focused effort on optimizing a single open source model can look like over many months. Not only on the inference serving side, but also on the harness optimization side and building custom workflows to narrow the gap between things frontier models can infer and deduce and what open source models natively lack due to size, training etc.

I also don't think a lot of people know some of the more advanced context management tricks like /rewind /fork /tree to take advantage of prefix caching

Zed has a "turn off all AI features" checkbox if you want to use that

It works well but there are a lot of missing features * skill auto complete * custom agents * sub agents * background process management

pgbackrest is awesome, truly. Thank you so much for the work you've put into this project over the years, and I'm sad the crunchy data acquisition couldn't keep the project alive.

We actually have one of these between our group of friends and their kids and it's awesome. The kids call each other to chat and setup play dates or to go run around in the street. Our kids will call back home to let us know they made it to the other persons house, or let us know they're coming back home too.

The tactility is incredible, and it's so just so cute to watch them chat away (5 year olds!)

Honestly, they can keep waiting for another year or two for on-device models at the size they're looking for to be powerful enough.

The way we solved it is by checking the lsn on the primary, and then waiting for the replica to catch up to that lsn before doing reads on the replica in various scenarios.

This is really tough in a large organization with features that cross across product domains.

Yeah, you'll definitely want to set things like `max_standby_streaming_delay` and friends to ensure things are bound correctly.

Gotta say, I love using PGDog. It has some fantastic built in features, and I'm looking forward to testing out the improved query parser. Lev and the team are heroes.

At the scale we were using PGDog, enabling the previous form of the query parser was extremely expensive (we would have had to 16x our pgdog fleet size).

I totally agree. I love watching a small set of animated films over the holidays in time order to really see the technical progress. It's especially fun to go from something nostalgic I loved as a kid, to something I can really see the technical underpinnings of today.

Both accessibility, and application security are easier to build rules + improved models for because they have pretty solid constraints and outcomes. UX on the other hand is definitely more challenging given how much of it isn't quite codified into simple rules.

I didn't write off an entire field of research, but rather want to highlight that these aren't intractable problems for AI research, and that we can actually start codifying many of these things today using the skills framework to close up edges in the model training. It may not be 100% but it's not 0%.

That may be true now, but think about how far we've come in a year alone! This is really impressive, and even if the models don't improve, someone will build skills to attack these specific scenarios.

Over time, I imagine even cloud providers, app stores etc can start doing automated security scanning for these types of failure modes, or give a more restricted version of the experience to ensure safety too.

I wouldn't be surprised if this paves the way for differing insurance rates on health markers given how magical glp-1s seem to be, and how much of modern disease is based on lifestyle factors.

a lot of the gen1 users will likely swap over to it though. They basically have dropped improvements for gen1 autonomy which is rug-pullish :(

One other thing I think it misses, is how easy it is to navigate a massive code base because everything looks the same. In a large team, this is crucial and I value the legibility over cleverness (I really dislike meta programming).

Really the only thing I found difficult is finding the concrete implementation of an interface when the interface is defined close to where it is, and when interfaces are duplicated everywhere.

I don't see a world where there is such a catastrophic failure, unless someone comes up with a significantly more efficient architecture.

We're barely scratching the surface of the utility of LLMs with today's models. They aren't more pervasive because of their costs today, but what happens if they drop another order of magnitude with the current capabilities?

Ok, the victorian lock puzzle game is pretty damn cool way to showcase the capabilities of these models. I kinda want to start building similar puzzle games for models to solve.

Yeah I agree, this seems like a pretty critical feature to the Aurora product itself. We saw a similar behavior recently where we had a connection pooler in between which indicates something wrong with how they propagate DNS changes during the failover. wtf aws

Yeah, this setup is both nice and insane. If you don't need much extra customization it's great. But I have a setup where I needed both postBuild and postRenderer's + actual kustomization layering and it was awful trying to figure out the order of execution to get the right final output.

In hindsight it would have been much faster to write the resources myself.

Love ambitious projects like this!

I wonder why the Unix standard doesn't start dropping old syscalls and standards? Does it have to be strictly backwards compatible?

This has a similar flavor to xata.io's SimplyBlock based storage system * https://xata.io/blog/xata-postgres-with-data-branching-and-p... * https://www.simplyblock.io/

It's a great way to mix copy on write and effectively logical splitting of physical nodes. It's something I've wanted to build at a previous role.