All of my SWE friends and coworkers agree this is a deeply weird time to be in the industry. LLM coding has dominated many (but not all) tech companies. Some of it is cool and exciting, but a lot of it is terrible and horrifying. I thought it could be a good time to do a vibe check.

Some possible questions to answer if you’d like:

• How has your work changed in the past year? How much of your daily work now involves LLM tools?
• Are you enjoying your work more, less, or the same? Has your relationship with work changed in general?
• Do you feel like you’re working more or less now? The same?
• Are you hopeful or fearful of the future (let’s say next 5 years) of SWE? Mixed?
• Have you found any useful tips or advice for thriving in the current landscape?
• Has your career trajectory changed? Do you plan on seeking out different types of roles?

Also it would be useful to give whatever background info you’re comfortable sharing to help ground things like: size of company, years of experience, type of role, location, etc.

Any and all discussion around the industry is welcome!

The prices have increased, and even before people called it too expensive.

I am just wondering - do you have one? What do you use it for? I've been thinking of getting one (as a business expense, I guess the price is high, but then again - what other option do you have for compute? renting GPUs is quite expensive, any comparable amount of VRAM is very expensive - ok if you have space and mostly want to do inference, I guess you have better options (3090 or 5090)

For me, I have just been considering having some more compute available for robotics, finetuning, trying out selfhosted and fine tuned LLMs, among other things. My other setup (M1Pro 32GB and a 1070 Mini) could work for some stuff, but especially for the robotics part it's mostly about NVIDIA...

Curious about any experiences.

In all the hype and debate and excitement and frustration around AI, I think sometimes the fact that we've achieved something really cool gets lost. I want to talk about that a bit, which I'll try to do in a simple way, without too much math or computer science.

There's a surprising amount of intelligence encoded in applied language. To me that's the most remarkable insight in LLM technology. Except it's not really surprising at all. The whole point of language is to encode intelligence. Communication, at its core, is about sharing intelligence. LLMs agents are a way of turning the intelligence encoded in language, particularly written language, into useful work.

You might imagine that language is just the starting point when building LLMs. That it gets converted into computer stuff and then it's not language anymore. But in a way it's language all the way down. Distill language into math and then run gradient descent on it and the intelligence (for lack of a better term) bubbles out.

Forgive that hyperbole, but there is something a little bit magical about it, and the technology is entirely unmagical. The magic is in the language.

At the core the tech is pretty simple. First you go and get all of the language. Just completely idiotic amounts of applied language. Because there's a threshold: if you don't use enough language you don't get a useful result. The more language you use, assuming it's good quality, the more useful the result.

After you have all of the language, you convert it into tokens, which are essentially pieces of words represented as numbers. You also compute a compressed version of the relationships between the tokens. The frontier labs don't say how much this costs publicly anymore but it's safe to say hundreds of millions in compute are required for this process. Each time you do it.

Once you've determined the token relationships, you've pre trained an LLM. You have the initial weights. At this point your LLM can output credible prose pretty reliably when you run inference on the weights. Meaning that you can take a given set of language tokens (a prompt) and determine which token should come next, over and over again, until you have a response. The fluency of the prose can be uncanny, and there are latent tendencies towards useful output, but you can't really do much with it yet.

The next step, fine tuning, modifies the weights in order to nudge the inference towards useful things like instruction following, tool use and reasoning. Or a simulacrum of reasoning. Fine tuning is a massive, multi step, iterative process that turns your LLM into a useful tool that can do more than output believable prose.

Something that's really fascinating to me about fine tuning is that what you're training is still the language relationship weights, and what comes out during inference is still language. But now it's language that is more likely to result in useful output and behaviors. Language is the substrate that LLMs reason through. A model that's more likely to infer the words "but what if I look at it another way" is more likely to consider multiple possibilities. A model that reliably infers language around tool use in appropriate situations is an agent. The behavior is encoded in the language.

After tens of millions in fine tuning costs, assuming you got it right, you have the core of a LLM that can function as an AI agent. You can put it in a harness and ask it to do things in the language of your choice and it will actually be able to do them a shockingly high percentage of the time. It can even do things that weren't explicitly part of the training. That's something which has never happened before outside of science fiction. Until recently it was one of those computer sciencey things that was probably going to happen someday, after we were all dead.

It sucks that this tech revolution is being driven by the capital class, and that it's happening as a mad dash for market domination and golden IPOs. In a more perfect world technology derived from collective human intelligence would be a public good rather than a profit driver.

But nevertheless, the ability to imprint some part of human intelligence into an autonomous agent is a remarkable achievement. One that we can't yet see the full size of. And it's possible not because we typed instructions into an interface, but because we've spent centuries encoding our intelligence into language.