The Human is the Agent: How SolveIt Changed My Programming Journey After 25 Years¶
I have been programming for over 25 years off and on, with a background in pre-AlexNet AI and having been a technical reviewer for AI publications and courses. As an early adopter of AI tooling and LLMs I thought I had a good sense of what AI could do for programming. Then I joined the first cohort of SolveIt students and something unexpected happened. Despite my experience with AI tools, SolveIt changed how I approach programming in ways I did not anticipate.
The first sign came during the Advent of Code challenges. Initially, it reminded me of university days over 25 years ago solving logic puzzles with AI like the cannibals and missionaries problem. As I worked through the problems with SolveIt, I found myself enjoying programming more than I had in years. My Python skills improved and refined, I was tackling challenges that would have previously left me stuck on my own or in frustrating spirals with LLMs.
What made the difference was not just another AI tool - it was a fundamentally different approach to how humans and AI work together.
How to SolveIt with code¶
The name SolveIt itself pays homage to George Pólya's classic mathematics book "How to Solve It" reflecting the platform's mission to help people tackle challenging problems, by combining practical skills with AI assistance rather than requiring a full computer science education.
Pólya's four-step problem-solving framework, first published in 1945, remains as relevant today as ever:
- Understand the problem: You must clearly see what is required of you.
- Devise a plan: Connect the data to the unknown to formulate a strategy for the solution.
- Carry out the plan: Execute the strategy you have devised.
- Review and extend: Look back at the completed solution to discuss it, check it and perhaps even use the same method to solve other problems.
What SolveIt does is embed these timeless principles along with much clever applied technology into a modern AI-assisted workflow, where each step becomes a collaborative dialogue between human insight and artificial intelligence capabilities.
Beyond Prompt Engineering¶
Jeremy Howard first mentioned "dialogue engineering" in the context of AI Magic on the Latent Space podcast well before the SolveIt course launched and I was intrigued by the concept. The idea of moving beyond traditional prompting approaches to create ongoing conversations with AI seemed promising, I did not fully grasp its power until I experienced it first hand.
Traditional AI coding tools, even sophisticated ones, follow a familiar pattern: you describe what you want, the AI generates code and you either accept it or iterate through increasingly frustrated prompting loops. Sometimes this helped, although it often felt like negotiating with a black box.
SolveIt operates on an entirely different principle: the human is the agent. Rather than asking the AI to solve problems for me, I found myself working with it in small, deliberate steps. To see this approach in action, Jeremy Howard and Johno Whitaker demonstrate the SolveIt methodology in this detailed walkthrough of SolveIt: The Thinking Developer's Environment, showing exactly how the interactive dialogue process works in practice.
A few of my SolveIt projects¶
When I wanted to build a context and style-aware image search engine combining CLIP, Stable Diffusion and FAISS with a FastHTML interface. SolveIt did not generate hundreds of lines of boilerplate code. Instead, we built it together piece by piece, with me understanding each component as we progressed. We implemented a prototype together in not too many hours and then improved upon adding in more search functionality. I learned enough FastHTML for the interface very quickly. Learning and implementing the technologies that were new to me would have taken much longer with traditional tutorials, reading and processing documentation. The iterative, dialogue-based approach made picking up all that was needed feel natural and easy, whilst leaving me with a more lasting understanding.
It was the same with my Stable Diffusion project, deploying previous research that used VGG features, style loss and latent MAE to steer/guide the difussion process. It was research I had started during the fast.ai part 2 course but I had not been easily able to deploy it. Yet SolveIt made the development process of the Gradio interface and deployment to Hugging Face spaces step by step, whilst being educational.
What struck me most was how this approach changed my thinking process. When I use SolveIt, I find myself initially pausing to carefully consider my prompts. Partly to anonymise my tasks for privacy, also to make them concise and understandable. I have learned to front-load the context and clearly specify my end goals before asking for any assistance. This deliberate preparation made every interaction much more productive.
The importance of being able to edit the AI output¶
Equally important is SolveIt's ability to edit the AI's responses directly, which fundamentally changes the dynamic of human-AI collaboration. Rather than being limited to append-only conversations like ChatGPT, SolveIt allows you to modify the AI's responses inline. Getting trapped in frustrating cycles of "that is wrong, try again" can actually teaches the AI to make more mistakes through its auto-regressive nature. With SolveIt I can simply edit the response to match exactly what I need. This creates a positive feedback loop where each correction improves the entire dialogue.
For example, if SolveIt suggests code too concise or verbose for my style or using coding syntax I do not use, I edit it to my preferred style directly in the response. When explaining complex concepts for my technical writing, I can refine the AI's explanations to match the precise level of technical detail needed for my audience. The AI learns from these edits, becoming increasingly aligned with my coding style, technical vocabulary and problem-solving approach throughout our conversation.
This direct editing capability transforms the AI from an LLM code generator that you have to negotiate with into a true collaborative partner that adapts to your expertise and preferences. Instead of fighting against the AI's tendency to produce generic responses heavily influenced by training data, you guide it towards solutions that are genuinely customised to your specific needs and understanding. Also, being able to remove or hide unnecessary parts of the conversation from the context. The result is code and content that feels authentically yours, because you have actively shaped every aspect of its creation.
How SolveIt Enables Dialogue Engineering¶
SolveIt's power comes from its unique technical architecture that makes dialogue engineering natural rather than forced. Unlike traditional chat interfaces or code generation tools, SolveIt is built as a literate programming environment where notes, executable code and AI interactions co-exist in a single, coherent document.
The platform's context-aware AI sees the entire dialogue history above each interaction - not just the immediate prompt, but every code cell, note, output and previous conversation. This persistent context allows the AI to understand the evolution of your thinking, the current state of your code and the broader goals of your project. When I'm working on a computer vision project, for instance, the AI remembers the libraries I have imported, the data structures I have defined and the specific challenges we have discussed earlier in the session.
The environment through its design encourages building solutions incrementally, typically one or two lines of code at a time, rather than generating large blocks of code all at once. Code cells execute immediately, showing outputs inline. You can "pop out" web applications into standalone URLs, visualise data instantly and see the results of each small step without context switching between tools. This immediate feedback loop makes the iterative, exploratory workflow feel natural rather than cumbersome.
Unlike traditional IDEs that have AI bolted on as an afterthought, or chat interfaces that treat code as just another text format, SolveIt is designed from the ground up for human-AI collaboration. The result is a tool that makes dialogue engineering the path of least resistance rather than a technique you have to learn and attempt to implement separately.
Unexpected Applications and Iterative Refinement¶
One of SolveIt's most delightful surprises was discovering how the dialogue engineering approach worked for non-coding tasks. Inspired by hearing Simon Willison's experiments with iteratively prompting "make it tastier" for recipes (following Max Woolf's "write better code" exploration), I decided to try something similar with SolveIt.
The result was my AI-generated roast potatoes recipe, where I used SolveIt's iterative refinement process to explore food science principles. Rather than accepting the first recipe suggestion, we worked through multiple iterations, discussing the Maillard reaction, optimal starch content and temperature control. Each refinement built on the previous version, creating not just a recipe but a deeper understanding of the underlying science. The final result was genuinely excellent roast potatoes and a fascinating exploration of culinary chemistry.
This experience highlighted something crucial about SolveIt's approach. Unlike traditional LLM interactions where "make it better" prompts can feel random or superficial, SolveIt's conversational context allows for meaningful progression. Each iteration builds genuine understanding rather than just cycling through variations.
I found the same principle applied to technical writing. When working on blog posts, I could discuss content back and forth with SolveIt, iteratively improving each section whilst easily applying changes in direction to previous sections. The AI understood the evolving context and helped maintain consistency across the entire piece.
The key difference from other AI tools became clear: SolveIt doesn't just generate content or code, it helps you think through problems systematically. Whether debugging a FAISS similarity search, optimising a diffusion model's guidance parameters, or perfecting the balance of herbs in a recipe, the process remains fundamentally the same - small steps, immediate understanding, continuous refinement.
Why This Approach Actually Works¶
After months of using SolveIt, I've noticed something profound about how it affects my thinking and productivity. Unlike the typical AI coding experience where you end up with mysterious blocks of code you do not fully understand, SolveIt ensures you comprehend every piece as it is built. It is like having an AI coding superpower where the resulting code is as understandable as if you had written it yourself, because in many and the most important ways, you have.
This is not just a subjective feeling. Recent research from MIT on "cognitive debt" reveals the hidden costs of over-relying on AI for complex tasks. When people use LLMs to generate entire essays or code blocks without engaging in the thinking process, they accumulate what researchers call "cognitive debt" - a measurable decline in memory, understanding and problem-solving ability over time.
Echoing some of Jeremy's words about tech debt, this holds true with cognitive debt - the debt metaphor is particularly apt when you consider how real financial debt works. The longer you hold cognitive debt, the more it costs you in terms of diminished capabilities. These costs accumulate over time - you lose not just immediate understanding, but the ability to build new knowledge on top of what you should have learned. Just as you pay interest on interest with financial debt, cognitive debt compounds, making each subsequent learning opportunity more difficult.
The study found that participants who used LLMs to write essays couldn't even quote sentences from their own work minutes after completing it. Their brain activity showed significantly reduced neural connectivity compared to those who engaged in the hard work of thinking through problems themselves. Most tellingly, when these LLM-dependent participants were later asked to work without AI assistance, their cognitive performance remained impaired.
Like financial debt, sometimes cognitive debt might be worth taking on - when you need to deliver something important quickly. But many developers take on this debt without thinking through whether they'll be able to "pay it off" later by actually understanding what was built. Worse still, trying to solve cognitive debt problems by generating even more AI code is like taking on more debt to pay off existing debts - a terrible strategy that only compounds the problem.
SolveIt sidesteps this trap entirely. By keeping you as the agent in every interaction, by working in small, comprehensible steps and by requiring your active participation in building solutions, it strengthens rather than weakens your cognitive abilities. You are not outsourcing your thinking - you are augmenting it.
This is why I can tackle some of the hardest Advent of Code challenges that would have previously stumped me, deploy complex multi-modal AI systems and even explore food science with genuine understanding. Each interaction builds competence rather than dependence.
Looking Ahead¶
Being among the first 1000 people to experience SolveIt has felt like witnessing the early days of a significant shift in how we work with AI. As someone who is a seasoned programmer, I have seen many programming paradigms and the advance of AI coding tools. What makes SolveIt different is not just another tool or framework - it is a fundamental rethinking of the human-AI relationship.
Jeremy Howard's insight about experienced programmers being particularly receptive to this approach is very accurate in my case. After years of coding and more recently adopting AI with coding, SolveIt addressed problems I did not even realise I had. The frustration of debugging mysterious AI-generated code, the time lost in prompt engineering loops, the gradual erosion of hands-on problem-solving skills - SolveIt eliminates these issues by design.
As I look at my experience with SolveIt, I think this is a better more sustainable approach to AI-assisted development. The current trend of ever more powerful models generating ever larger blocks of code feels unsustainable. SolveIt offers a different path. By maintaining human agency, working in comprehensible increments and building genuine understanding at each step, it creates a positive feedback loop where both human and AI capabilities grow stronger over time. This represents a partnership model that builds competence over time rather than creating dependence.
The implications extend far beyond programming. Whether I am implementing computer vision algorithms, exploring culinary science, or writing technical articles - the same principles apply. Small steps, continuous understanding, iterative refinement and always keeping the human as the agent in the process.
I am grateful to be part of this first cohort and excited to see where this approach leads. After 25 years of programming, it is refreshing to find a tool that makes me better as a programmer rather than just faster at producing code I don't fully understand.
If the SolveIt approach appeals and resonates with you, look out for the next cohort signup announcement. Follow Jeremy on https://x.com/jeremyphoward.
Chris Thomas is an AI consultant and solutions developer with over 25 years of programming experience. He has been learning about and using AI since 1997. You can find more of his work at christhomas.co.uk.