Introducing the AI Tutor agent

The problem

The world of software development is changing. AI will most likely continue to become a vital part of the software development flow. In my own experience I have noticed that it is very easy to loose the connection to your code base when AI is doing most of the development.

I therefore present the AI Tutor agent, that will help you retain/gain the knowledge that otherwise is so easily lost to the machine.

The solution

---
description: Socratic tutor. Investigates the question like plan (explores,
reads code, finds the root cause) but guides you to the answer yourself with
targeted questions, hints, and file:line references instead of answering
directly. Use when you want to learn, not just get the fix.
mode: primary
permission:
  edit: deny
---

You are Tutor, a Socratic software engineering tutor.

## Workflow

1. Investigate first. Before responding, do the same work a plan-mode agent
   does: search the codebase, read the relevant files, trace the code, find the
   real cause. Get evidence (file:line). Never guess.

2. Then teach, don't answer. You know the answer, but your job is to make the
   user find it themselves. Start with one pointed question aimed at the key
   insight — often "what do you expect X to do here, and what is it actually
   doing?"

3. Let the user work. Follow each of their answers with a question that moves
   them one step closer. One question at a time. Short turns. No walls of text.

4. Escalate only when needed. If the user is genuinely stuck after a real
   attempt, or asks "just tell me", escalate in this order: hint → narrower
   hint → point to the exact file:line and ask what they notice → full
   explanation. Don't reveal the answer before that.

5. Ground everything in code. Cite file paths and line numbers so the user can
   verify every claim themselves.

6. Close the loop. Once the user gets it, have them state the fix or next step
   in their own words, confirm it, and end with a one-line summary of the
   underlying principle.

## Rules

- Read-only. Never edit files or run mutating commands. Suggest what the user
    should try or change — the user does it.
- If the question is about general knowledge rather than this codebase, still
    teach: ask what they think first, then build on it.
- Praise correct reasoning briefly and specifically. Correct wrong reasoning by
    pointing at evidence, not just saying "wrong".

If you are using the opencode harness, put that markdown in ~/.config/opencode/agent/tutor.md and restart the current session. For other harnesses, the setup is a similar, just ask them and they will guide you to it.

The agent in action

I was working on a simple word search generator for one of my kids.

I had this working initial grid generator

use rand::seq::IndexedRandom;
use std::{array, fmt};

#[derive(Debug)]
struct Grid {
    alphabet: Vec<String>,
    grid: [[String; 10]; 10],
}

impl Grid {
    pub fn new(alphabet: Vec<String>) -> Self {
        let grid: [[String; 10]; 10] = array::from_fn(|_| {
            let row: [String; 10] =
                array::from_fn(|_i| 
                  alphabet.choose(&mut rand::rng())
                    .unwrap()
                    .clone()
                  );
            row
        });
        Self { alphabet, grid }
    }
}

impl fmt::Display for Grid {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        for row in &self.grid {
            for row_cell in row {
                write!(f, "| {} ", row_cell)?;
            }
            writeln!(f, "|")?;
        }
        Ok(())
    }
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // ["MONKEY", "BANANA"] for non Swedish readers
    let dictionary = ["APA", "BANAN"];
    let alphabet = vec![
        "A".to_string(),
        "B".to_string(),
        "C".to_string(),
        "D".to_string(),
        "E".to_string(),
        "F".to_string(),
        "G".to_string(),
        "H".to_string(),
        "I".to_string(),
        "J".to_string(),
        "K".to_string(),
        "L".to_string(),
        "M".to_string(),
        "N".to_string(),
        "O".to_string(),
        "P".to_string(),
        "Q".to_string(),
        "R".to_string(),
        "S".to_string(),
        "T".to_string(),
        "V".to_string(),
        "W".to_string(),
        "U".to_string(),
        "X".to_string(),
        "Y".to_string(),
        "Z".to_string(),
        "Å".to_string(),
        "Ä".to_string(),
        "Ö".to_string(),
    ];

    // let grid_size = (10, 10);
    let grid = Grid::new(alphabet);

    println!("{}", size_of::<Grid>()); // 2424 bytes, will become
                                       // 1600 bytes, after &str conversion

    Ok(())
}

I want to direct your attention to one particular flaw with this implementation. We store multiple copies of the strings from the alphabet in the Grid struct making it unnecessarily big. We can do better by storing references (&str) but I always find lifetimes to be annoying when dealing with structs. I could ask my local AI to do it for me but I would not become more proficient with my struct lifetime handling. So lets ask the Tutor to assist us with our change.

Here is the conversation I had with the Tutor agent

At this point I had changed the implementation to this.

use rand::seq::IndexedRandom;
use std::{array, fmt};

mod db;

#[derive(Debug)]
struct Grid<'a> {
    grid: [[&'a str; 10]; 10],
}

impl<'a> Grid<'a> {
    pub fn new(alphabet: Vec<&'a str>) -> Self {
        let grid: [[&str; 10]; 10] = array::from_fn(|_| {
            let row: [&str; 10] =
                array::from_fn(|_i| *alphabet.choose(&mut rand::rng())
                    .unwrap()
                  );
            row
        });
        Self { grid }
    }
}

impl<'a> fmt::Display for Grid<'a> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        for row in &self.grid {
            for row_cell in row {
                write!(f, "| {} ", row_cell)?;
            }
            writeln!(f, "|")?;
        }
        Ok(())
    }
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // ["MONKEY", "BANANA"] for non Swedish readers
    let dictionary = ["APA", "BANAN"];
    let alphabet = vec![
        "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N",
        "O", "P", "Q", "R", "S", "T", "V", "W", "U", "X", "Y", "Z", "Å", "Ä",
        "Ö",
    ];

    // let grid_size = (10, 10);
    let grid = Grid::new(alphabet);

    println!("{}", grid);

    Ok(())
}

pub fn new(alphabet: Vec<&'a str>) -> Self {

Conclusion

My short interaction with the Tutor for this fix was very pleasant, I even went on a side quest and explored that clippy lint that it mentioned. Getting a instructor tailored to the thing you are working on currently is great. I hope you found it interesting and will give it a spin.

Appendix - Final code

I ended up saving 33% of the memory used for the Grid structure. While this was not the point of this post I really do feel that I got a better grasp on the change instead of having asked the AI to just do it for me. I will definitely be using this at work to ensure that I don't lose track of the code base while still being able to leverage the extreme power of AI.

use rand::seq::IndexedRandom;
use std::{array, fmt};

mod db;

#[derive(Debug)]
struct Grid<'a> {
    grid: [[&'a str; 10]; 10],
}

impl<'a> Grid<'a> {
    pub fn new(alphabet: &[&'a str]) -> Self {
        let grid: [[&str; 10]; 10] = array::from_fn(|_| {
            let row: [&str; 10] = array::from_fn(|_i| *alphabet.choose(&mut rand::rng()).unwrap());
            row
        });
        Self { grid }
    }
}

impl<'a> fmt::Display for Grid<'a> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        for row in &self.grid {
            for row_cell in row {
                write!(f, "| {} ", row_cell)?;
            }
            writeln!(f, "|")?;
        }
        Ok(())
    }
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let dictionary = ["APA", "BANAN"];
    let alphabet = vec![
        "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N",
        "O", "P", "Q", "R", "S", "T", "V", "W", "U", "X", "Y", "Z", "Å", "Ä",
        "Ö",
    ];

    // let grid_size = (10, 10);
    let grid = Grid::new(&alphabet);

    println!("{}", grid);
    println!("{}", size_of::<Grid>()); // 1600 bytes

    Ok(())
}