That a raw LLM hallucinates?

That we never see all the mistakes and dead ends a complex system using AI hits?

Does it even matter if its accuracy rate across all its experiments is < 100% if it can run trillions of experiments in the same time a human could run 1?

We don't see many of the failed attempts of Human Researchers. Why? Because it doesn't matter.

What amazing here is that it shows our society can make discoveries faster in the post LLM world. Thats incredible.

Your "critique" of how it happened. Not so much.

Before code hits a humans eyes it's went through a few independant review passes from our review agents.

If it's low complexity / blast radius it gets auto merged.

If it's high complexity / blast radius it gets flagged for human review.

And funny enough our team has agreed even our human review layer has the best results if we have an agent create supplementary descriptions of the code and potential issues that we read and apply human judgement.

Reason being is that it can be very pendantic. Both in a good and bad way. Either flagging things that are non-concerns, or catching things my lazy human eye wouldnt have caught. e.g. A docstring mis-describing the actual shape of an object.

While it may not have sold millions of units and been a household staple.

It certainly focused the entire org on manufacturing a suite of chips and hardware that are on a completely different level than their competitors. Apple's now has a clear advantage in all dimensions that matter: compute, power consumption, size, capabilities, etc.

Apple Vision helped created a moat that will be hard for anyone else to cross for at least a decade.

So we had a few goals here

1. Be opinionated on best practises, tools and libraries

2. Not get in the way of what the developer wants to do

To that end the core is built on top of Temporal, and our llm package is a thin wrapper around ai-sdk that provides QoL enhancements (Prompt files, tracing, cost tracking etc..)

So for failures in general, and tool calling specifically there are two levels of retries.

1. ai-sdk level tool retries: The library by default handles tool call failures and will retry if the LLM deems it a transient issue, and will never hard fail if one of its tool calls in unsuccessful (unless perhaps you instruct it to).

2. Temporal level activity failures: Our workflows and steps are all configured with a base line affordance to reattempt steps that have failed. You as the developer are able to change this, you can make it so a step is never retried, or retried say 100 times with exponential backoff.

Hope that helps!

So the API keys during setup are entirely optional. They're used in the example workflow that evaluates blog posts for clarity and provides feedback on how to improve.

Youre more than free to ignore/delete the example workflow and create your own that doesn't make use of an LLM 1. Fetching trending hn posts 2. Pulling reddit posts that match keywords 3. Transforming Daily calendar events into an html page etc..

And the claude code plugins (that are installed for you) all work with you Anthropic subscription no problem

I own a stake in a small brewery in Canada, and this feature just saved me setting up some infrastructure to "productionize" an agent we created to assist with ordering, invoicing, and government document creation.

I get paid in beer and vibes for projects like these, so the more I can ship these projects in the same place I prototype them the better.

(Also don't worry all, still have SF income to buy food for my family with)

This is a reason why we made our http framework (@outputai/http) a first class citizen for the greater framework and our claude code plugins.

As you pointed out at this moment in time theres a Cambrian explosion both in new tools/libraries and the willingness to use them, which poses a systemic security threat when combined with how LLMs function.

So while you're free to use any third party tool or library you want with Output. We encourage you to roll your own as often as possible both for the security/control it gives you. But also for the vertical integration it provides (debugging, cost tracking, evals etc...)

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

Points: 40

# Comments: 11

We have some new tools that increase productivity, and these same tools both lower the barrier to entry to understanding software concepts and building software.

I think the result is more people who would've been traditionally considered non-technical are going to be onboarding to concepts that wouldve been traditionally ring fenced in the developer world.

Granular version control and diffs being one of them.

If this trend is real, and relatively large, I think it will be a good thing.

I had assumed they would've had a better plan to film the entire departure from orbit yesterday.

I'm at least happy they have one for the loop around the moon.

If I could wave a magic wand to reset any programming language adoption at this point I would choose Python over Javascript.

I think Pythons execution model, deep OO behaviour, and extremely weak guarantees have done a lot of damage to the soundness and performance of the technology world.

2. Commercial Datacenters (theyre ahead at least)

3. Chip production (Google is manufactoring proprietary chips)

4. Consumer OS (Chrome, Andriod)

5. Consumer Hardware (Pixel)

Basically google has access to data that OpenAI will never have access to, can lower costs below what OpenAI can, and is already a leader in all the places OpenAI will need massive capex to catch up.

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

Points: 2

# Comments: 0

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

Points: 2

# Comments: 0

I'd layer in a few more

* Largely stable and unchanged language through out its whole existance

* Authorship is largely senior engineers so the code you train on is high quality

* Relatively low number of abstractions in comparisson to other languages. Meaning there's less ways to do one thing.

* Functional Programming style pushes down hidden state, which lowers the complexity when understanding how a slice of a system works, and the likelyhood you introduce a bug

Its also why you'll hear many engineers opine over functional programming.

Most start by thinking about 1. What does a system do for me?

Then onto 1. What actions does a system do? 2. Where should files and folders live? 3. Where should services live?

and stop there.

But the true key is when you just think about how data moves through your system.

Then you learn to simplify.

No classes, no hidden state, just simple functions with an input and an output and nothing else.

Long story short: Think about your system in data, and learn how to keep your code super simple to help with that thinking

We're not debating majority opinion here. Just that people exist who have that bias / perception and what it leads to.

People exist that judge and exclude based on if you have have an Android.

Im sure the reverse exits too.

Im also sure the former is more common than the later.

But I have no idea how large that population is.

Just like Im not in that population.

Heres some examples

- https://www.reddit.com/r/Android/comments/1nt7czg/do_iphone_...

- https://www.reddit.com/r/samsung/comments/14rhes2/friends_in...

- https://www.reddit.com/r/Nicegirls/comments/1ja3iy4/green_bu...

- https://www.reddit.com/r/OnlineDating/comments/17xrue5/are_y...

- https://www.reddit.com/r/datingoverthirty/comments/b6w9iu/oh...

- https://www.reddit.com/r/Tinder/comments/f1i3q8/this_is_why_...

- https://www.reddit.com/r/Android/comments/rz4wlp/why_apples_...

----

One more:

https://mashable.com/article/iphone-users-think-less-of-andr...