RobinL

$20 chatgpt pro plan gives pretty generous usage both of codex, general chat

Interesting. I don't have to use PowerPoint much, but I hate it when I do. I don't want the llm to write the words but I do want it to make things look nice. So does this work well now?

I'm been impressed when testing this model today, but it still can't consistently adhere to the following prompt: make me an image of a pizza split into 10 equal slices with space in between the them, to help teach fractions to a child.

It doesn't reliably give you 10 slices, even if you ask it to number them. None of the frontier models seem to be able to get this right

Please retain vega lite speech as an option! It's incredible useful because you can tweak the chart or change it completely at a later date using e.g. the vega lite editor.

Thanks, interesting. Does this make it more surprising that the other benchmarks have improved? I'm not sure I understand the benchmarks well enough - but I'm wondering whether with agentic workflows it's possible to get away with a smaller more focussed context (and hence lower cost) whilst achieving the same or better performance, because of agentic model's ability to decide what the put in context as they work

Could this be because they've found the 1m context uneconomical (ie costs too much to serve, or burns through users quota too quickly causing complaints), and so they're no longer targeting it as a goal

There's a section in the docs of our FOSS record linkage software that covers this: https://moj-analytical-services.github.io/splink/topic_guide...

The letters are based on how they're formed in the UK primary school curriculum.

Each letter is a json that defines the bezier curves according to a schema.

They were created by starting by drawing the letters freehand, yielding essentially a dot to dot, and then (2) using an approximation/smoothing algorithm to convert that into beziers. Finally,I went through touching up/fixing each letter by hand, using a purpose built editor.

So I would say overall it's more time consuming than challenging.

That stills leaves the problem of joining letters together. For that I heavily lent on AI to propose an algorithm, although it required a lot of back and forth to get something even semi decent. At the moment it's probably 'good enough' but there's still lots of room for improvement.

On the countries quiz, you should be able to move and zoom on the bloge using click and drag (or pinch and drag on mobile). Letter constellations uses shaders. Both of those are only tested on Chrome, so that might be the issue.

Example letter: https://github.com/RobinL/letterpaths/blob/main/packages/let...

JSONSchema

https://github.com/RobinL/letterpaths/blob/main/packages/let...

Editor

https://www.robinlinacre.com/letterpaths/editor

Thank you! Noticed you're interested in similar areas. I've also previously done some work on maths problem generation. Similar to letterpaths, the core lib can then be used to power games/other educational apps. As I'm sure you've found as well, It's surprisingly difficult to generate random maths problems aligned to a curriculum! Core lib is UK-focussed: https://github.com/RobinL/maths-game-problem-generator

And examples of games is can power:

https://rupertlinacre.com/maths_vs_monsters/

https://rupertlinacre.com/breakout_maths/

https://rupertlinacre.com/maths_blaster/

letterpaths (https://github.com/RobinL/letterpaths), a FOSS typescript library that can power cursive handwriting/educational apps for kids.

The idea is that it provides all the geometry to enables games like these to be built: (These are just rough demos)

https://www.robinlinacre.com/letterpaths/writing_app/snake/

https://www.robinlinacre.com/letter_constellations/

And here is like the admin/demo: https://www.robinlinacre.com/letterpaths/

And, separately, I made an educational country quiz, again FOSS:

https://rupertlinacre.com/country_quiz

https://github.com/RupertLinacre/country_quiz

I work on an open source record linkage library called Splink. The list of features I want to add has always been far larger than the time I have. I enjoy working with LLMs because they have enabled me to work through my backlog much faster.

I think the primary reason I enjoy working with them is that coding, for me, has always been a means to and end. I like the product of it more than the process. This quote sums it up quite well for me:

> People are really worried about their jobs. And I just want to remind them that the purpose of your job and the tasks and tools that you use to do your job are related, not the same. I've been doing my job for 33 years. I'm the longest running tech CEO in the world, 34 years. And the tools that I've used to do my job has changed continuously in the last 34 years, and sometimes quite dramatically, you know, over the course of a couple, two, three years.

Source: https://lexfridman.com/jensen-huang-transcript

5.4 is great. I use it for python professionally and for typescript/front-end games and educational apps recreationally. In my experience it's roughly as good as opus, just a lot cheaper. It's amazing how much usage you get for $20/mo

I love this! Thanks for the detailed response, super interesting

Wow, that's big! I'm curious, how much does the 600kWh battery cost nowadays? Amazing that the tech has got to a point this is even possible

It's also widely misunderstood. Just because the spot price of electricity is set by the price of gas doesn’t mean the consumer pays that price for all of their electricity.

A lot of wind and solar are on Contracts for Difference. That means when market prices go above the agreed level, the generator pays the difference back through the scheme, which reduces supplier costs rather than the generator simply keeping the whole windfall.

This is particularly relevant when e.g. the price of gas goes way up due to the Iran war, it doesn't mean that the consumer ends up paying more for the energy from wind

Why would additional storage make a significant difference to the price of gas?

For me, it's beyond doubt these tools are an essential skill in any SWE's toolkit. By which I mean, knowing their capabilities, how they're valuable and when to use them (and when not to).

As with any other skill, if you can't do something, it can be frustrating to peers. I don't want collegeues wasting time doing things that are automatable.

I'm not suggesting anyone should be cranking out 10k LOC in a week with these tools, but if you haven't yet done things like sent one in an agentic loop to produce a minimal reprex of a bug, or pin down a performance regression by testing code on different branches, then you could potentially be hampering the productivity of the team. These are examples of things where I now have a higher expectation of precision because it's so much easier to do more thorough analysis automatically.

There's always caveats, but I think the point stands that people generally like working with other people who are working as productively as possible.

This is great! Would be nice if it could hyperlink from the nodes directly to the khan academy modules/learning materials

One thing missing but important to understand is the energy embodied in buying 'stuff'. At a very rough approximation, the cost of stuff, especially consumer goods manufactured cheaply, is quite a high percentage energy.

When you look at people's energy usage, quite a lot of it ends up being the embodied energy in the stuff they buy. For quite a lot of people, it's probably the largest category of energy consumption. I once had a very rough go at calculating this here: https://www.robinlinacre.com/energy_usage/

Certainly the initial versions were post processing rather than native. I'd be interested to know if that has changed on subsequent releases.

Or possibly 'men find the algorithmic/consumption based platforms relatively more appealing' and so were quicker to leave

Love this! Would be super interested in any details the author could share on the data engineering needed to make this work. The vis is super impressive but I suspect the data is the harder thing to get working.

Agreed! The first piece of software I built was a simple inventory and sales management system, around 2000. I was 16 and it was just about my first experience programming.

It was for school, and I recently found the write up and was surprised how well the system worked.

Ever since I've marvelled at how easy it was to build something highly functional that could incorporate complex business logic, and wished there was a more modern equivalent.

My wife's old company, a fairly significant engineering consultancy, ran it's entire time/job management and invoicing system from a company wide, custom developed Microsoft Access app called 'Time'.

It was developed by a single guy in the IT department and she liked it.

About 5 years ago the company was acquired, and they had to move to their COTS 'enterprise' system (Maconomy).

All staff from the old company had to do a week long (!) training course in how to use this and she hates it.

In future I think there will be more things like 'Time' (though presumably not MS Access based!)

Agree. Much of the value of devs is understanding the thing they're working on so they know what to do when it breaks, and knows what new features it can easily support. Doesn't matter whether they wrote the code, a colleague wrote it, or an AI.

> saw absolutely zero value in it

At the very least, it can quickly build throwaway productivity enhancing tools.

Some examples from building a small education game: - I needed to record sound clips for a game. I vibe coded a webapp in <15 mins that had a record button, keyboard shortcuts to progress though the list of clips i needed, and outputted all the audio for over 100 separate files in the folder structure and with the file names i needed, and wrote the ffmpeg script to post process the files

- I needed json files for the path of each letter. gemini 3 converted images to json and then codex built me an interactive editor to tidy up the bits gemini go wrong by hand

The quality of the code didn't matter because all i needed was the outputs.

The final games can be found: https://www.robinlinacre.com/letter_constellations https://www.robinlinacre.com/bee_letters/ code: https://github.com/robinL/

Does anyone have direct experience with Claude making damaging mistakes in dangerously skip permissions mode? It'd be great to have a sense of what the real world risk is.

I think that's totally fine for individual work, but in larger data engineering teams it's less good to switch between tools because other people may have to maintain your code.

That said, polars is good, and if the team agree to standardise on it then that's a totally reasonable choice.

I guess one of my reservations is I've been (historically) burned by decisions within data eng teams to use pandas, causing all sorts of problems with data typing and memory and eventually having to rewrite it all. But I accept polars doesn't suffer from the same problems (and actually some of them are even mitigated in more recent versions of pandas)

Worse in some ways, better in others. DuckDB is often an excellent tool for this kind of task. Since it can run parallelized reads I imagine it's often faster than command line tool, and with easier to understand syntax

Found myself nodding along. I think increasingly it's useful to think of PRs from unknown external people as more like an issue than a PR (kind of like the 'issue first' policy described in the article).

There's actually something very valuable about a user specifying what they want using a working solution, even if the code is not mergeable.