joshribakoff

I guess that depends on what you define productivity as. It seems that you have a preconceived narrow definition. If I pay millions of dollars in taxes that fund a war, who is to say that was more productive than planting a tree and taking a nap.

Fightingwithai.com - a collection of vendor agnostic patterns for operating ai coding agents in the style of gang of four / fowler

This is a very low quality submission. Its a vibe coded app that gives me a chat ui. When i ask for soup it shows me t shirts.

10 minutes after your comment I checked and I don’t see any pgsql credentials, but I do see that they have committed their local settings instead, including their local file paths now.

The API is a way to access a model, he is criticizing the model not the access the method (at least until the last sentence where he incorrectly implied you can only script a local model, but I don’t think thats a silver bullet, in my experience that is even more challenging than starting with a working agent)

This commit graph seemingly shows that they fixed a couple bugs over like a week. Period that involves changing like six lines of code. That code has no abstractions no structure and several problems you could poke holes in. While it may work and that’s great for whoever benefits, this isn’t very convincing as I can currently write more than six lines of code per day by hand

90% of the time people are praising the benefits of AI it seems like they are copy pasting something from their Chatbot so you’re not far off.

While its thought provoking no one can claim to know the future with absolute certainty.

I am not an electrician, but when I did projects, I did a lot of research before deciding to hire someone and then I was extremely confused when everyone was proposing doing it slightly differently.

A lot of them proposed ways that seem to violate the code, like running flex tubing beyond the allowed length or amount of turns.

Another example would be people not accounting for needing fireproof covers if they’re installing recessed, lighting in between dwelling in certain cities…

Heck, most people don’t actually even get the permit. They just do the unpermitted work.

There is an argument here that the LLM is a tool that can multiply the addition or removal of the defects depending on how it is wielded.

To add onto this, it is a characteristic of their design to statistically pick things that would be bad choices, because humans do too. It’s not more reliable than just taking a random person off the street of SF and giving them instructions on what to copy paste without any context. They might also change unrelated things or get sidetracked when they encounter friction. My point is that when you try to compensate by prompting repeatedly, you are just adding more chances for entropy to leak in — so I am agreeing with you.

In one instance it could not even describe why a test is bad unit test (asserting true is equal to true), which doesn’t even require context or multi file reasoning.

Its almost as if it has additional problems beyond the context limits :)

You may want to try using it, anecdotes often differ from theories, especially when they are being sold to you for profit. It takes maybe a few days to see a pattern of ignoring simple instructions even when context is clean. Or one prompt fixes one issue and causes new issues, rinse and repeat. It requires human guidance in practice.

- claudes tool search tool - list of skills (markdown files) the agent can grep - claude skills - context compaction - sub-agents - plans

There is no one “right” pattern. But yes it all generalizes to context engineering.

With plans for example, you write out potential distractions for later, to keep (the AI and the Human context) focused on a task at hand.

That pattern solves a distinctly different use case than the skills folder, but plans can also refer to skills in specific ways.

Context engineering is evolving with overlapping complementary patterns, and while certain vendors are branding patterns, i think we will hopefully we see tools converge.

The good news is that an llm will be really helpful in scraping your content locating alternative service providers or even creating your own solution so you can migrate away

There are some potential biases here.

Of course it is unimpressive when someone does something familiar to you, that is subjective. That same thing could be framed as impressive, to someone else, such as the person who is now able to do the unfamiliar as if it is familiar.

The other bias would be to assume that there aren’t unfamiliar things (you don’t know every tool every made, therefore you may potentially benefit from using AI to help with learning new tools).

Another bias is to assume AI is only good for learning something unfamiliar. There are ways to contain generative coding that scale, in some contexts. Likewise there’s probably use cases even for power users, like organizing messy desktop icons into semantic clusters (automating tedious tasks), summarizing running processes, limiting engagement with brain rot, etc.

If you’re doing TDD, you could just view this as moving the “open” call to your unit test. As others point out, that encourages pure functions that can pipe in input from other sources than just file paths.

Yea i was imprecise, thank you for clarifying.

It’s relevant because it answers the “headline” question of why the market is charging for/gatekeeping free software. The answer is obviously because thats what capitalism incentivizes.

I think this is a pretty narrow take. Without going into too much detail I can imagine many use cases. For example, there is a whole class of predictive algorithms and one limitation is that data has to be cleaned, ingested, and feature engineered. For example, clustering is only as good as your vectorization. With an LLM, it is easy to imagine predictive use cases that skip entire etl pipelines and just directly operate on less structured inputs, not just summarizing those inputs, but actually making decisions or predictions. You’re already seeing frameworks like BERT-topic integrating LLMs (for labeling topics), that is already far removed from the “3 use cases” listed here.

By fine tuning llm based predictive systems we might unlock entirely new use cases, and prediction is just one thing i imagine, there are many other use cases.

And then it’s not just the fact that frameworks like bert-topic are integrating LLMs. It’s also the fact that if you zoom out the architecture looks a lot like the architecture of an LLM… text -> embedding -> text

An LLM could and is already being used to generate recommendations systems, like the ones used at Youtube and Netflix, it captures more semantics than older techniques.

Thanks for sharing. As someone who used dragon naturally speaking, which did fine tuning back in the 90s, i was genuinely surprised at the implementation gap.

Astro does the same, or something similar, but without an extension i think — https://docs.astro.build/en/reference/experimental-flags/chr...

It seems to leverage some official chrome devtools workspaces concept.

You are potentially conflating combinations with permutations.

I see value in backfilling missing / obtuse documentation, i also see potentially negative value if used instead of improving or reading existing docs. Ideally Plotly would have a developer guide that is higher quality than what an LLM can dervive.

I don’t find the developer experience to be good, its not just the lack of types altogether but also the delays imposed by having compilation steps to run tests.

A lot of the affordances in the ecosystem have been supplanted by more modern solutions for many use cases, like Kubernetes.

Elixir also opens a number of footguns like abuse of macros; these are some of the reasons to second guess switching.

I think that one of the strongest reasons for switching would be that if you are willing to trade off all of this in exchange for the ability to do zero downtime deploys, not just graceful shutdowns and rollovers. Like if you’re building a realtime system with long lived interactions, like air traffic control system or live conferencing systems.

It can sometimes feel like an esoteric or regrettable choice for a rest api or rpc/event driven system. Even if you want a functional language there may be better choices like kotlin.

High level: hit github api, feed code to llm, display results in web app.

If you want to learn web apps start with the docs, eg. Official react docs or even just learning vanilla JavaScript if you don’t know it.

Start with little pieces like hitting the github API and displaying some json in the terminal

You could also just start prompting an llm to scaffold a project for you and then trying to debug whatever issues come up (and they will)

Then the service seems to provide zero value, there are already “untrusted” platforms. If i have to anonymize myself anyways, i can just post on Reddit/Twitter/Orange site directy.

The use case here is to reduce the token usage with LLMs, such as an agent that outputs a list of commands eg. Tuples with files to write and their new contents.

Supporting this use case doesn’t require perfectly marshaling every data structure ever.

But to your point the tool could have wider use cases without the limitations.

The verbosity.

To your point abstractions often multiply and then hide the complexity, and create a facade of simplicity.

There’s no reason to unilaterally dismiss others use cases, this debate is as old as ReactJS (mixed JS and HTML).

Modern tools often make this tradeoff, like Astro, and none of the tools authors are claiming you need to use the tool.

Yes, the pattern can be abused, but dogmatic rules against mixing languages may also entail downsides.