That's a harness concern, not a protocol concern. For example, maki [0] allows that automatically for all tools

> code_execution tool - uses monty to run an interpreter that has all other tools available as async functions. Maki uses it to filter / summarize / transform / pipe data to other tools as input, without it ever reaching and polluting the context window. Sandbox limited by time & memory.

Failing that, you can just disable native MCP in your harness and have your agent use a CLI tool that calls MCP, like mcp-cli [1], and then the agent can use regular unix pipes to filter or transform the output. Here, rather than raw grep or sed (which are line oriented), the agent would probably use things like jq.

[0] https://github.com/tontinton/maki#context-efficiency

[1] https://github.com/philschmid/mcp-cli

Not all platforms want to operate like mainstream social media though

I actually came to the comments to share this snippet

> The hot operation isn’t really “fold this character,” it’s “does this character fold?” Almost always no.

Really that's distracting. If you must use LLMs, also do a rewrite pass that removes most LLMisms

> if licenses permit.

As if licenses mattered in the LLM era

Case in point

https://news.ycombinator.com/item?id=48466812

> In looking at the code that the LLMs have produced for the project, especially given the pretty massive and widespread architectural changes needed to make the implementation libified and memory safe, we decided that the codebase is not a derivative work that would require carrying forward the GPL license and have decided to release the code under the MIT instead.

LLM are copyright laundering machines

Not only they launder copyright from Internet at large, they can also launder from specific targets

> As if licenses mattered

They still do, if you want your changes be made public, or even upstreamed.

No sane license that gives access to the source code forbids modification for internal use; one reason is that it would be really hard to enforce.

Grit isn't made for internal use though, and it's still changing the license

I am doing something similar to that C-to-Rust rewrite. Except: 1) I'm clearly saying that it's only for my own learning experience and to find ways to improve the original program 2) I am leaving the original license in place and explicitly treating the output as a derivative.

And yet I am worried that my actions are perceived as hostile. Some people just don't care.

Firefox cryptographic primitives are written and formally verified in F*

Some Windows things too I think (I think F* is partially funded by Microsoft Research)

They actually wrote a whole verified TLS implementation in F* and discovered a bunch of TLS vulnerabilities in other implementations

https://project-everest.github.io/

https://github.com/hacl-star/hacl-star

https://blog.mozilla.org/security/2017/09/13/verified-crypto... (note, that's from 2017, so, not exactly new.. not sure how this is not more well known)

The source is actually all training data, plus the software used for training, including some scripts or instructions to run the entire thing end to end on your own computer. That's what open source has always been about.

The weights are the output of a program, it's a binary. It's not source.

It makes no sense for me that @apply is frowned upon. It's what makes Tailwind actually kinda usable for me. Without it, markup looks like line noise full of boilerplate that's hard to modify in a systematic way.

I think what Tailwind actually needs is more abstractions, not to discourage the use of the sole abstraction @apply

Using @apply defeats the entire purpose of Tailwind. The point of it is to localize styling alongside the markup. If you're using @apply then you're constantly context switching from your markup to your CSS files while working.

There's plenty of ways to manage the bevy of classes you need. First step is making use of components to deduplicate stuff. Then in those components, use a library like class-variance-authority aka "cva()" which allows you to set up complex named presets for your components (like size="small" or color="primary" and things like that).

I use @apply in quite a few projects, mainly because I like the defaults in tailwindcss. I know it defeats the point of tailwind, but I find that it works nicely when using BEM.

I genuinely don't understand, why would you use `@apply text-center` instead of `text-align: center`?

Like if you're already at the point of setting up stylesheets & classes with a pre-processor why would you do that and not say use scss with some mixins for the more complex reused parts? At that point any IDE plugin that knows CSS can give you completion and your compiled sources will look a lot like the written ones in the dev tools.

Personally I wouldn't use `@apply text-center` over just `text-aligh: center;`, but I do use `@apply text-red-300` or `@apply px-2`, simply because I like the set of defaults Tailwind comes with.

I tried building my own set of defaults, but eventually decided that just using the Tailwind ones is much easier.

The type theory of Lean is certainly rich enough though

if your article is about how your product was insufficient to protect against something, you get a pass i guess

But perf improvements not only mean you can run the same thing on cheaper hardware, you can also run more capable models in the same hardware

In this sense, any advance in intelligence is a performance improvement and vice versa