-
In search of intermediate abstractions
Working with LLM generated code effectively requires some intermediate abstractions.
Teams using LLMs to build software are still figuring out how to handle the mountain of code that now needs read if you aren't delegating all of that to agents. I'm increasingly convinced we need interventions that support human comprehension of code, for many individual and organisational reasons. Reading all of our generated code line by line is not feasible, but referring purely to specifications, prompts etc that were used to generate it is inadequate when it comes to knowing what is actually going on in a system.
We need intermediate levels of abstraction that help us to be more strategic about what we attempt to understand in codebases.
Read more... -
Harnesses are just software
Learning what is happening in the software around the model.
When I decided I wanted to make a programming learning tool that incorporates LLMs, I chose to build for IDEs, starting with VS Code. I did that because I believed there would be value in steering people back towards code, and because it would let me build with LLMs in a model agnostic way. What's happening with open models and model companies in general is making me glad I didn't target one of their platforms.
A "war dog" being fitted for a parachute harness.
Read more... -
I am once again asking for a run button
Sometimes it isn't the most complicated things that put people off learning.
I’m building a thing to help people understand codebases. A primary use case I have in mind is someone who has no coding experience but has vibe coded an application they now find themselves needing or wanting to understand. You’d be forgiven for assuming the hardest part of this would be helping people learn how their implementation works, but you might be wrong.
My years teaching coding skills have shown me that what blocks progress and kills momentum is often not the code, but surrounding tasks like setting up developer environments, deployment and all that. My project uses the debug flow in VS Code, I’m getting frustrated at the lack of sensible defaults in place.
Read more... -
The proofs are in the pudding
Learning about static analysis is teaching me about robustness and effectiveness.
I’ve been making myself describe the project I’m working on so that I can get input on some design decisions. I stumbled on a timely LinkedIn post about how Claude Code works. It touches on static analysis, something I’m having to learn a wee bit about for my project. The post is focused on claims of machine understanding – I’m not particularly interested in those kinds of conversation as I don’t see the value. However the detail might speak to the limitations of LLMs in practice, which I do care about because it affects the power of this technology to undermine labour. But I digress.
Read more... -
What comes after view source?
We still need pathways for people to understand how software systems work.
This week during the inaugural Write Through It we got onto the subject of View Source. Kin reflected on what the loss of this pathway means for opportunity and the web over on his blog, which got me thinking about it once again.
Read more... -
Being intentional about friction
Pondering what Glitch tells us about friction and developer learning when LLMs can generate code.
This time last year I was building paths for folk migrating apps away from Glitch. We were approaching the shutdown date and I needed alternatives for the Fastly onboarding projects I'd used as the foundation of the learning program I was leading – and that I’d candidly been hoping to integrate enough into product onboarding that the company would be persuaded to keep Glitch around. I also had a more personal need to figure out alternatives, as I'd relied on Glitch for teaching much longer than I'd been employed to work on it.
Read more...
-
Which direction is forward?
Software role changes tell us something about the goals in LLM deployment.
There’s a role that appears to be exploding in popularity in AI adjacent companies right now: the Forward Deployed Engineer. Since I first heard about LLM assisted coding, aside from the very real enabling potential, I’ve worried that the outcome would be a future where fewer people understood how critical systems worked. I believe some of what we’re seeing with these jobs is a reflection of that.
Read more... -
Pedagogy is the way
Looking back at three years of thinking and posting about ai assisted coding.
It’s three years since I first wrote about AI assisted coding. You can still read that post on the Glitch blog: Software development isn't writing syntax
A lot has happened since then, but as I said in a weirdly popular LinkedIn post recently, my beliefs have proven pretty resilient – tl;dr:
Read more... -
On convenience and understanding
Can we leverage automation while still preserving understanding?
"There is some compulsion in software where automation breeds more automation and we accidentally leap over the phase where it was actually optimal for both usefulness and understanding." Me, on mastodon the other day
Being able to generate code is forcing us to figure out when it’s a good idea to actually write it.
Read more... -
How should we teach software development now?
Exploring software development learning topics in the context of AI-assisted coding.
Yesterday I posted on LinkedIn about realising I've been thinking and writing about AI-assisted coding for three years now, and that overwhelmingly I still stand by the positions I've taken. My first public post on the subject was in May 2023, so I'm going to revisit it on the same day this year. But for now, since the discussion touched on what we should be teaching on software engineering courses, it prompted me to jot down my current thinking, still very much WIP but here you go.
Read more...
.jpg){kind=link}