Why I love SolveIt

I have been using SolveIt since late 2024 as part of the first cohort of students, and honestly could not recommend it more. After spending more time with the platform, its growing functionality and tools, certain features stand out to me as genuinely unique in AI tooling.

Concise by design

SolveIt responses are concise. I find some other platforms almost unusable because of the length of their replies. It is too much effort to read through pages of response and you simply do not take it all in. SolveIt is different. Even in Learning mode, SolveIt is far more concise than other platforms. In Concise mode it is razor sharp.

I once tried replicating the SolveIt style with another provider. At the time SolveIt only supported Anthropic models and they were down, so I tried giving another platform detailed instructions including acting as a Socratic teacher. We were working together to create a recipe. At the end of a long session I just wanted it to summarise the recipe and the steps. It refused. Truly Socratic, it would not break character. I had to tell it I would be very hungry if it did not give me the recipe so I could actually use it. That problem is solvable with a clause in the prompt, but it illustrates the gap. SolveIt knows when to teach and when to deliver.

Concise responses also mean efficient token usage, which matters for both cost and environmental reasons. Less time reading filler, more time building.

Then there are the two modes, Learning and Concise. I almost always use Learning mode. It can feel like coding with training wheels on, but training wheels with resistance. It drags you back, forces you to think about what you are doing. The grind of getting the initial thoughts, planning and encoding right is the point. That is where you learn. The payoff is that you build genuine understanding rather than dependency. As the dialog grows, the resistance fades and the momentum is yours.

Model selection within a single dialog is powerful. I can start with a stronger model to establish good context, then switch to a less expensive model as the dialog grows or bounce back and forth when precision matters.

Editing the dialog and context

The ability to edit previous message history is, for me, the most important feature. Most AI tools treat conversation history as fixed. You send a response, realise the AI misunderstood something three steps back and you are stuck in an increasingly broken thread. SolveIt lets you go back, fix the earlier message and continue. The context repairs itself. This alone changes how I work.

Editing also keeps the context concise. By trimming tangents and correcting misunderstandings at source, you reduce the total token count. I suspect this also helps with the lost-in-the-middle problem that plagues long contexts. Not only because your context is shorter, but because you have carefully edited the flow so the conversation does not drift off track. I only have my own observations to back this up, but the difference in coherence over long dialogs is noticeable.

In SolveIt the context can get smarter, not dumber, as it increases. As the dialog grows, SolveIt becomes more honed into your way of thinking. It is aligning itself with your thoughts and reinforcing the direction your brain is going.

I often wonder why other providers do not allow editing of the conversation history. LM Studio lets you do it locally, but most cloud platforms lock the history. I suspect they see editable context as an attack vector. LLMs are autoregressive and editable history could theoretically lead them past safeguards. But in SolveIt, that autoregressive nature is precisely why editing works so well. You can almost teach the model the direction you want to go. You can let it get something wrong once, then correct the earlier message yourself to show how it should be done on the second attempt. Even if the model failed the first time, the corrected context guides it properly the next. You steer rather than restart.

It is like debugging your own thought process. When you edit a response to match what you actually meant, you are not just fixing a mistake. You are conditioning the autoregressive flow of the entire dialog. The next response is generated based on the corrected version, not the flawed one. Get trapped in "that is wrong, try again" cycles with other tools and you reinforce the wrong path. Each failed attempt becomes part of the context, making the next attempt more likely to fail in similar ways. SolveIt lets you rewrite the history.

Over a long dialog this builds into something where the context is so aligned with your thinking that the conversation starts to flow as if from a single mind rather than human and LLM.

Close reading

Close reading is where SolveIt becomes something else entirely. The idea is simple: treat a video lecture like a dense text, reading it slowly with an AI partner that challenges you. See the excerpt at the end of this post for an example. I extract transcripts from YouTube, SolveIt tools to embed video segments and key screenshots inline and FastAnki to generate personalised Anki cards from my specific confusions. The same approach works for research articles, papers and any long text. Anywhere you need to read deeply rather than skim.

Code cells are part of the conversation in SolveIt, not a separate tool. You run code inline, see the output and keep talking about it with the AI seeing what you see. When concepts need precision or a numerical check, you reach for the Python kernel rather than a text answer. LLMs are probabilistic text predictors and arithmetic in a text response is unreliable. The right tool for the right task.

The loop works in small chunks. Watch a short segment, explain your understanding back, get challenged if you are wrong, discuss until it clicks. No hand-waving past confusion. Then generate Anki cards from the gaps you discovered. Spaced repetition locks it in. If the Anki cards surface new questions, you return to the dialog, ask those questions and the understanding loop continues.

The rules matter. Ask stupid questions, they are where learning happens. Set anti-sycophancy, the AI should push back. Stay honest to source pacing, do not jump ahead. Think in small chunks because slow learning compounds.

The deeper principle is what makes it work. Passive watching is fast, intuitive and gives an illusion of understanding. Close reading is slow, deliberate and effortful. Anki then trains the fast intuition back from the deliberate work. The friction is the learning.

With SolveBlog, close reading now goes full circle. You can turn the output of your close reading sessions into a blog post with ease. Writing about what you have learned reinforces your own understanding and helps you share that learning with others. The loop extends beyond your own head.

Mastery

SolveIt is not selling productivity, it is selling mastery. The human remains the agent. The tools get better, the loops get tighter, but that never changes. If SolveIt were a car, its bumper sticker would read: Warning. Human still driving.

Thanks to Jeremy and all the team at Answer.AI for creating such a wonderful tool.

A few of the similes and metaphors in this post may have come from SolveIt interviews and descriptions of other machine learning work. They are apt here. Debugging your thought process and the bumper sticker are mine.

An excerpt from one of my close reading sessions of a fast.ai lesson.

To demonstrate how close reading can work, here is an excerpt from a real close reading session on the fast.ai Practical Deep Learning for Coders part 2: Deep Learning Foundations to Stable Diffusion, Lesson 24: Attention & transformers. The topic is attention mechanisms but the workflow is what matters.

This method was adapted from a notebook shared by Answer.AI's Rens Dimmendaal, with a few tweaks and adding in Anki cards.

Section: Self-attention module with X Plus addition (1:09:03–1:13:23)

Key points:

• Final output: transpose back, reshape back to original shape, then add to original X (residual connection)
• This is "self-attention ResNet style" — diffusers includes the X+, some implementations (like PyTorch) don't
• The module just needs to know number of channels (for the 4 projections and group norm)

Optimization trick: Instead of 3 separate projections (Q, K, V), use ONE projection from ni → ni*3, then .chunk(3) to split. More concise and faster (less CPU-GPU back and forth).

Testing: Copy weights from your implementation to diffusers' attention block — if outputs match, your implementation is correct.

sqkv = nn.Linear(ni, ni*3)
st = sqkv(t)
st.shape

q,k,v = torch.chunk(st, 3, dim=-1)
q.shape
     

([email protected](1,2)).shape

class SelfAttention(nn.Module):
    def __init__(self, ni):
        super().__init__()
        self.scale = math.sqrt(ni)
        self.norm = nn.BatchNorm2d(ni)
        self.qkv = nn.Linear(ni, ni*3)
        self.proj = nn.Linear(ni, ni)
    
    def forward(self, inp):
        n,c,h,w = inp.shape
        x = self.norm(inp).view(n, c, -1).transpose(1, 2)
        q,k,v = torch.chunk(self.qkv(x), 3, dim=-1)
        s = ([email protected](1,2))/self.scale
        x = s.softmax(dim=-1)@v
        x = self.proj(x).transpose(1,2).reshape(n,c,h,w)
        return x+inp
     

sa = SelfAttention(32)
sa(x).shape
     

The close reading continues in small sections

Then there's continued loops of this watching/reading in small chunks, with the benefit of the context of what I've learnt and understood so far.

The result is I've added personalised Anki cards for repetitive spaced learning, which I can tweak later if needed.