Teaching Programming With AI Is Now an Evidence-Based Decision

Most conversations about generative AI in programming courses still run on instinct. One camp wants to ban the tools to protect the fundamentals. The other wants to adopt them quickly so students are ready for an industry that has already changed. Both positions get argued from conviction, and both skip the step that should come first: looking at what the research says.

That step is now possible. In the past two years, computing education researchers have produced enough studies to move the question from opinion to evidence. The findings do not hand a clean win to either camp. They support bringing AI into the programming classroom, and they show that doing it badly can widen the gap between students who are already succeeding and those who are struggling. The case for integration and the case for careful design turn out to be the same case.

What the tools are good at

Start with the capability question, because for the types of problems we usually assign, it is no longer in serious dispute. Current large language models solve the kinds of problems we assign in introductory courses. A review of the field by Paul Denny and colleagues documents how code-generation tools went from a curiosity to a standard part of the programming workflow in a matter of months, and how readily they handle the small, well-specified problems that fill most CS1 assignments. The exam evidence is concrete. When James Finnie-Ansley and colleagues ran OpenAI’s Codex through two CS1 tests in 2022, its answers ranked seventeenth in a class of seventy-one, inside the top quartile, and that was an early model. Newer ones have only widened the margin.

The industry signal points the same direction. In April 2025, Microsoft’s CEO said as much as 30% of the company’s code was being written by AI. That figure is a remark on a conference stage, not a measured result, and “written by AI” has no agreed definition, so it deserves caution. As a marker of where professional practice is heading, though, it is hard to ignore. If we want graduates who can work the way their future colleagues already work, ignoring the tools is its own kind of risk.

The second strength is tutoring. A first-year case study by Liam Stienstra and colleagues used a ChatGPT-based tutor to teach a new topic, then tested students without assistance. The tool supported learning, and most students preferred the AI tutor to a human one. Their reasons are worth considering: it was always available, and it did not make them feel judged for asking a basic question. Purpose-built tutors push this further. Tools like CodeHelp, from Mark Liffiton and colleagues, and CodeAid, from Majeed Kazemitabaar and colleagues, wrap the model in guardrails so it nudges a student toward an answer instead of handing one over. Work by Harsh Kumar and colleagues, run across a classroom study and a larger controlled experiment, found that the structure an instructor puts around the tool changes how students use it. Guidance that prompted students to attempt a problem before turning to the model, or to reflect on their own thinking, cut down on aimless queries and on the habit of pasting an assignment straight into the chatbot verbatim without attempting it first.

There is also early evidence that the help does not vanish the moment the tool is taken away. In a controlled study, Kazemitabaar and colleagues gave sixty-nine beginners, ages ten to seventeen, a sequence of forty-five Python tasks. Half had an AI code generator during the authoring work. That group completed more tasks and scored higher on the authoring work. The natural worry is that they would fall apart once the tool was gone. They did not. On the modification tasks they had to do by hand, they performed no worse than the students who never had access. On a retention test a week later they came out slightly ahead, though the difference was not statistically significant. Encouraging and modest at once, which is the honest way to hold it.

So far this is the authentic optimistic story. It is also incomplete.

The catch is an equity problem

Learning with AI is not automatic, and the students it fails are the ones we should worry about most.

The clearest evidence comes from James Prather and colleagues, in a study with the apt title “The Widening Gap.” Using eye-tracking and think-aloud methods with novice programmers, they found that every metacognitive difficulty students had before AI is still present, and that new ones have appeared. The pattern that is concerning: students with higher grades and stronger self-efficacy used the tools to accelerate, while weaker students were often slowed down and left with what the authors call an illusion of competence. The work finished but the understanding did not. The same tool that helps a confident student move faster can help a struggling student fail without noticing.

Part of the reason can be found in a paper by Lev Tankelevitch and colleagues on the metacognitive demands of generative AI. Working with these systems asks the user to do things that are cognitively hard: state a goal precisely, break it into parts, judge whether the output is any good, and adjust course when it is not. The authors compare it to a manager delegating to a team. That is a demanding skill, and it is not one novices arrive with. Studies of how beginners actually use these tools back this up. A close look by James Prather and colleagues at novices working with Copilot found students leaving out details that matter, like input and output types, and, when a prompt failed, changing a few words in the prompt rather than supplying the missing requirements.

This is where the equity lens is needed. A tool that rewards students who already plan well, monitor their own understanding, and know what they do not know will tend to reward the students who were going to do fine anyway. Left unaddressed AI creates a larger equity gap.

What evidence-based design looks like

The same body of research points to what helps, and the through-line is consistent: slow students down enough to make them think, and build the supports that strong students supply for themselves.

Majeed Kazemitabaar and colleagues tested this directly. They compared a baseline that simply showed students AI-generated code with an explanation against seven techniques that required some engagement with the code before or after it appeared. The technique that worked best, called Lead-and-Reveal, brought what students thought they had learned closest to what they actually learned, without adding cognitive load. The effects were modest and the samples small, which the authors are candid about, but the direction matches everything else in the literature. Passive acceptance of generated code produces the illusion of learning. Forcing a small act of reasoning interrupts it.

Other design moves follow from the same logic. Scaffold the tool rather than handing it over, as Kumar’s guidance strategies did. Teach prompting as an explicit skill, since novices do not pick it up on their own. Move assessment toward process and away from the take-home artifact that a model can now generate in seconds. And give upper-level students structured practice with the messier task they will actually face at work: a study by Anshul Shah, Leo Porter, and colleagues taught students to use GitHub Copilot inside a large codebase and found a pattern they call one-shot prompting, where students ask the tool to build an entire feature at once and then spend their effort debugging what comes back. That is a teachable habit, and naming it is the first step to correcting it.

There is a quieter finding that reframes the whole debate. A 2025 replication study by Rita Garcia and Michelle Craig revisited a 2004 survey of what CS1 instructors teach and find hard to teach. Twenty years on, the basic concepts are largely unchanged, recursion is still the hardest thing to teach, and the newest challenge instructors name is teaching students to think and plan before they code. That difficulty predates generative AI. The shift toward planning, decomposition, and self-monitoring, the very skills AI makes more important, was already underway. The course it was happening in was already struggling: introductory programming has carried high failure rates for decades, documented by Jens Bennedsen and Michael Caspersen and revisited by Christopher Watson and Frederick Li, and the long line of work on Soloway’s rainfall problem, surveyed by Kathi Fisler, showed that many students finish CS1 unable to write a basic loop correctly. AI did not break the introductory course. It exposed problems the course already had.

You do not have to figure this out alone

The research is scattered across conferences and journals, which makes it hard for any individual instructor to assemble. That gap is part of what the Consortium for Generative AI in CS Education https://www.teachcswithai.org/about exists to close. Housed at UC San Diego’s Center for Research on Education, Assessment, and Teaching Excellence and led by Leo Porter, Daniel Zingaro, and Beth Simon, the consortium gathers course materials, research summaries, and a community of educators working through the same questions. Its partner network runs from professional bodies like ACM and SIGCSE to organizations focused on access and inclusion, which matters given what the research shows about who gets left behind. The point of the consortium is not to sell a position. It is to make the evidence usable, so that a faculty member redesigning a course in the summer is not starting from a blank page. About half of the articles I used for this article can be found in the consortium’s resources section.

Two of the consortium leads, Porter and Zingaro, have also written the classroom-ready version. Their book, Learn AI-Assisted Python Programming, reorders the introductory course around the skills the research elevates. They argue that the skills to write good software are evolving: problem decomposition, writing a specification, reading code, and testing matter more than they used to, while memorizing syntax and library details matters less.  Two of the chapters teach students to read code, on the logic that if the assistant writes the code, the student’s job is to judge whether the assistant has done what the student intended. A full chapter covers testing and prompt engineering. Top-down design, the practice of breaking a large problem into smaller ones, runs across several chapters rather than appearing once. Debugging gets its own deep dive, a skill that think-aloud studies by Jacqueline Whalley and colleagues show novices tend to approach unsystematically. Porter and Zingaro grant that a future professional engineer should eventually learn to write code from scratch, but they argue it no longer makes sense as the starting place for most learners. That is a concrete answer to the camp that wants to ban the tools to protect the fundamentals: they are just sequenced differently and weighted toward the skills that matter most now, like reading code, testing, and breaking problems down, rather than writing syntax from memory.  The book is available to the IU community through IUCAT on the Bloomington and Indianapolis campuses, in digital ebook (https://iucat.iu.edu/catalog/20590350) and streaming audio (https://iucat.iu.edu/catalog/21587005) formats.

What about large courses?

Class size does not change the goals, but it splits these design moves into two groups. Some work just as well with three hundred students as with thirty and cost the instructor no extra effort. Requiring an attempt before a student reaches for the tutor is a policy built into the assignment or the tool, not labor spent per student. Kumar’s guidance strategies were tested as exactly this kind of scalable intervention. The cognitive-engagement step is the same: Kazemitabaar’s Lead-and-Reveal shipped as a reusable task builder, so the prediction step runs for every student without the instructor touching it. The AI tutor itself has its strongest case here. Kumar frames LLM tutors as a response to growing class sizes where teacher presence is thin, CodeHelp was built for scalable support in large classes, and Stienstra’s students valued the tutor because it was always available, which a human teaching assistant in a 400-person course cannot be.

The moves that resist scale are both forms of assessment. Reading hundreds of process artifacts or grading prompts by hand does not work past a certain size. The realistic versions are to make the process artifact auto-gradeable or peer-reviewable, push it into teaching-assistant-led lab sections, assess prompts by outcome rather than by reading each one, and reserve the labor-heavy formats like oral checks for a rotating sample. The teaching of these skills scales fine, since a lecture is a lecture. The grading is what has to be redesigned.

Underneath this is the equity point. In a small class you can see who is drifting. In a large one, the student coasting on an illusion of competence is invisible, and that is the student Prather’s widening-gap study identifies as most at risk. The large-course adaptation is a triage logic: let the tools that scale support the median student, and aim scarce human attention, teaching-assistant hours, oral checks, early-alert outreach, at the students the tools are most likely to fail. Spreading human help evenly is the thing a big course cannot afford and the thing struggling students most need.

The opportunity

The strongest argument for bringing AI into programming education is not that the tools are impressive, though they are. It is that they force a reckoning with weaknesses the field has tolerated for decades: introductory courses where many students do not learn what we think they learn, and a persistent distance between what we teach and what graduates need. We can treat that reckoning as a threat to manage or as a chance to fix the course. The evidence says the fix is within reach, and that it depends less on the tools than on how we design around them.

A few things to consider trying next term:

  • Replace one take-home assignment with an in-class task that assesses process, not just the finished program.

  • Before students use an AI tutor, require them to attempt the problem and write down what they think the answer should be.

  • Teach one short lesson on writing a specification for a model, including input and output types, and grade a prompt the way you would grade code.

  • Pick a single cognitive-engagement move, such as having students predict what generated code will do before running it, and use it consistently for a unit.

References

  • Denny, P., Prather, J., Becker, B. A., Finnie-Ansley, J., Hellas, A., Leinonen, J., Luxton-Reilly, A., Reeves, B. N., Santos, E. A., & Sarsa, S. (2024). Computing Education in the Era of Generative AI. Communications of the ACM. https://doi.org/10.1145/3624720

  • Finnie-Ansley, J., Denny, P., Becker, B. A., Luxton-Reilly, A., & Prather, J. (2022). The Robots Are Coming: Exploring the Implications of OpenAI Codex on Introductory Programming. Australasian Computing Education Conference (ACE ’22). https://doi.org/10.1145/3511861.3511863

  • Kazemitabaar, M., Chow, J., Ma, C. K. T., Ericson, B. J., Weintrop, D., & Grossman, T. (2023). Studying the Effect of AI Code Generators on Supporting Novice Learners in Introductory Programming. CHI ’23. https://doi.org/10.1145/3544548.3580919

  • Prather, J., Reeves, B. N., Denny, P., Becker, B. A., Leinonen, J., Luxton-Reilly, A., Powell, G., Finnie-Ansley, J., & Santos, E. A. (2023). “It’s Weird That it Knows What I Want”: Usability and Interactions with Copilot for Novice Programmers. ACM Transactions on Computer-Human Interaction. arXiv:2304.02491

  • Liffiton, M., Sheese, B., Savelka, J., & Denny, P. (2023). CodeHelp: Using Large Language Models with Guardrails for Scalable Support in Programming Classes. Koli Calling ’23. arXiv:2308.06921

  • Kazemitabaar, M., Ye, R., Wang, X., Henley, A. Z., Denny, P., Craig, M., & Grossman, T. (2024). CodeAid: Evaluating a Classroom Deployment of an LLM-based Programming Assistant that Balances Student and Educator Needs. CHI ’24. arXiv:2401.11314

  • Prather, J., Reeves, B. N., Leinonen, J., MacNeil, S., Randrianasolo, A. S., Becker, B. A., Kimmel, B., Wright, J., & Briggs, B. (2024). The Widening Gap: The Benefits and Harms of Generative AI for Novice Programmers. ICER. https://doi.org/10.1145/3632620.3671116

  • Tankelevitch, L., Kewenig, V., Simkute, A., Scott, A. E., Sarkar, A., Sellen, A., & Rintel, S. (2024). The Metacognitive Demands and Opportunities of Generative AI. CHI ’24. https://doi.org/10.1145/3613904.3642902

  • Kumar, H., Musabirov, I., Reza, M., Shi, J., Wang, X., Williams, J. J., Kuzminykh, A., & Liut, M. (2024). Guiding Students in Using LLMs in Supported Learning Environments: Effects on Interaction Dynamics, Learner Performance, Confidence, and Trust. CSCW. https://doi.org/10.1145/3687038

  • Kazemitabaar, M., Huang, O., Suh, S., Henley, A. Z., & Grossman, T. (2025). Exploring the Design Space of Cognitive Engagement Techniques with AI-Generated Code for Enhanced Learning. IUI ’25. https://doi.org/10.1145/3708359.3712104

  • Stienstra, L., Mohamed, A., & Mohamed, M. (2025). Exploring GenAI as a Tutoring Tool: A Case Study in First-Year Computer Programming. ITiCSE ’25. https://doi.org/10.1145/3724363.3729060

  • Shah, A., Chernova, A., Tomson, E., Porter, L., Griswold, W. G., & Soosai Raj, A. G. (2025). Students’ Use of GitHub Copilot for Working with Large Code Bases. SIGCSE ’25. https://doi.org/10.1145/3641554.3701800

  • Garcia, R., & Craig, M. (2025). 20 Years Later: A Replication Study on Teaching CS1 Concepts. ACM Transactions on Computing Education. https://doi.org/10.1145/3730405

  • Whalley, J., Settle, A., & Luxton-Reilly, A. (2023). A Think-Aloud Study of Novice Debugging. ACM Transactions on Computing Education. https://doi.org/10.1145/3589004

  • Fisler, K. (2014). The Recurring Rainfall Problem. ICER ’14. https://doi.org/10.1145/2632320.2632346

  • Watson, C., & Li, F. W. B. (2014). Failure Rates in Introductory Programming Revisited. ITiCSE ’14. https://doi.org/10.1145/2591708.2591749

  • Bennedsen, J., & Caspersen, M. E. (2007). Failure Rates in Introductory Programming. ACM SIGCSE Bulletin. https://doi.org/10.1145/1272848.1272879

  • Porter, L., & Zingaro, D. Learn AI-Assisted Python Programming, Second Edition: With GitHub Copilot and ChatGPT. Manning (Function). Kindle Edition. Available via IUCAT, Bloomington and Indianapolis campuses: ebook https://iucat.iu.edu/catalog/20590350, streaming audio https://iucat.iu.edu/catalog/21587005

  • Novet, J., & Vanian, J. (2025, April 29). Satya Nadella says as much as 30% of Microsoft code is written by AI. CNBC.

  • Consortium for Generative AI in CS Education, UC San Diego CREATE. Faculty leads: Leo Porter, Daniel Zingaro, Beth Simon. https://www.teachcswithai.org/

  • Porter, L. Research on GenAI and Learning To Program [Video]. YouTube. https://www.youtube.com/watch?v=faY5gDTlvs0

Read More
Akesha Horton Akesha Horton

Join me at Educause

On Thursday, June 11th, I will be discussing "Designing for Authentic Assessment: A Community Toolkit for Generative AI Integration in Computing Education." This session will discuss my progress on a research study examining how faculty integrate generative AI into computing education. This is just one of many conversations taking place at the Teaching and Leaning Symposium, sponsored by #EDUCAUSE. I hope to see you there! Learn more and register here: https://events.educause.edu/symposiums/2026/new-approaches-to-assessment-design-for-ai-enabled-learning

EDUCAUSE Advertisement for a Teaching and Learning Symposium on June 9th and June 11th

Looking for more updated posts from me? See my substack.

Read More
Akesha Horton Akesha Horton

Making Thinking Visible in the Age of AI

Woman sits at desk. Her lap top is open. Her coffee cup has the word FOCUS on front of it and is filled with hot coffee as indicated by the steam. She appears to be thinking while writing in her notebook.

In a previous post, I walked through Fink’s Taxonomy of Significant Learning and argued that the dimensions most resistant to AI offloading are Human Dimension, Caring, and Learning How to Learn. If you have not read that post yet, it is worth starting there. This post picks up where that one left off.

Knowing which dimensions to target is necessary. The harder question is this: once you have redesigned an assignment to require Integration, Caring or Learning How to Learn, how do you actually know whether the student’s thinking got there? How do you make that thinking visible, not just to yourself, but to the student?

Why Thinking Must Be Seen

Let me start with an honest admission. Long before AI arrived, most of us were already assessing products and hoping the thinking happened somewhere in the middle.

A student submits a system design proposal. We grade the proposal. But did the student genuinely wrestle with tradeoffs? Did they consider the user population? Did they revise their mental model partway through? We have no idea, because the process was invisible to us.

Bransford’s foundational work on how people learn keeps returning to the same finding: learning is the result of thinking, not the result of submitting. Students arrive with preconceptions already formed. If we do not actively engage those preconceptions, new information slides off. They perform for the test and revert to old models the moment the course ends.

AI has not created this problem. It has simply removed our excuse for not solving it.

When a student can generate a convincing network architecture diagram in thirty seconds, or produce a well-structured post-mortem without ever having reflected on anything, the gap between product and thinking becomes impossible to ignore. The question is no longer “did the student submit something good?” It is “did the student actually think?”

Eight Thinking Moves That Matter

Ron Ritchhart, Mark Church, and Karin Morrison spent years researching what happens in classrooms where deep learning consistently occurs. Their conclusion, documented in Making Thinking Visible, is that those classrooms share one quality: the teachers have found ways to make the thinking process explicit, observable, and routine.

They identify eight types of thinking that matter most in deep learning:

  • Observing closely and describing what is there

  • Building explanations and interpretations

  • Reasoning with evidence

  • Making connections

  • Considering different viewpoints and perspectives

  • Capturing the heart and forming conclusions

  • Wondering and asking questions

  • Uncovering complexity and going below the surface

Read that list through the lens of Fink’s dimensions. Making connections is Integration made visible. Wondering and asking questions is Learning How to Learn in action. Considering different viewpoints is Human Dimension surfacing in real time. Capturing the heart and forming conclusions is Caring given a concrete form.

🗂️

Interactive chart To see the full picture of how each thinking type maps to Fink’s dimensions, explore the Fink-Ritchhart Connection Chart. Hover over any card to see which dimensions a thinking type activates and why the connection exists. It is a practical audit tool to keep open when you are reviewing an assignment or selecting a routine.

→ Open the Fink-Ritchhart Connection Chart

Fink tells us which dimensions produce significant learning. Ritchhart gives us the thinking moves that actually get students there.

The bridge between them is the thinking routine: a short, structured, repeatable cognitive scaffold that makes the reasoning process visible to both the instructor and the student, before, during, or after an assignment. The key word is repeatable. A thinking routine used once is an activity. Used consistently, it becomes a habit of mind.

What It Looks Like in Practice

The most common objection I hear from computing faculty is that thinking routines feel like they belong in a humanities classroom. They do not. Here is what they look like in technical contexts, alongside what an AI-generated response to the same prompt would typically produce.

Connect-Extend-Challenge in a Cybersecurity Course

After students analyze a new class of vulnerabilities, rather than simply asking them to summarize what they learned, ask three questions: What connections do you see between this attack surface and techniques you have encountered before? How does it extend your mental model of how systems fail? What does it challenge in your current assumptions about secure design?

🎯 Fink dimension:Integration


What AI output looks like: A fluent, well-organized paragraph connecting the vulnerability class to common attack taxonomies, citing OWASP or MITRE ATT&CK — with no personal frame of reference and no indication of cognitive struggle or surprise.

What authentic visible thinking looks like: A response that names a specific system or course context the student is connecting to, identifies a genuine point of confusion or revision in their thinking, and asks a follow-up question they actually want answered.

Think-Puzzle-Explore Before a Systems Design Assignment

Before students begin a major design task — architecting a distributed data pipeline or specifying a real-time embedded system — ask them to spend ten minutes on three prompts: What do you already think you know about this problem space? What puzzles you about it? What would you want to explore before committing to a design direction?

🎯 Fink dimension:Learning How to Learn


What AI output looks likeA generic overview of the problem domain, a list of standard considerations (latency, fault tolerance, scalability), and a suggested exploration path drawn from documentation.


What authentic visible thinking looks likeIdiosyncratic puzzles specific to this student’s prior experience, honest uncertainty about where to start, and questions that reflect what they personally do not yet understand rather than what the internet says is hard.

I Used to Think / Now I Think at Project Completion

At the end of a software engineering project, before students submit their final documentation, ask them to complete two sentences: “I used to think [X] about [the problem, the technology, the team process]” and “Now I think [Y].” Require them to explain what changed their thinking.

🎯 Fink dimensions: Caring&Learning How to Learn


What AI output looks like: A polished reflection arc that describes growth in general terms, references course concepts correctly, and lands on a tidy conclusion about professional development.


What authentic visible thinking looks likeSomething specific — a named moment in the project where a decision backfired, a teammate conversation that reframed the problem, a line of code that revealed a misunderstanding the student did not know they had. Specificity is the signal.

Design Principle: Assess the Process

When you cannot assess the thinking directly, make the process the assessment.

This does not mean adding reflection questions as an afterthought. It means designing the assignment so that the thinking process is where the grade actually lives.

In an introductory programming course, this might mean asking students to annotate their code not with what it does but with why they made the choices they made. Not “initialize array here” but “I chose an array over a linked list because access patterns here are random and I wanted O(1) lookup, but I am not sure this holds if the input size grows.” That annotation is a window into reasoning that the code itself cannot provide.

In a networking or operating systems course, it might mean asking students to document their debugging process rather than just their solution. What did they try first? What did that tell them? What did they have to revise? The process log is where the learning lives. The solution is just evidence that the process concluded.

In a capstone or project course, it might mean maintaining a design decision log throughout the semester. Every significant choice — whether architecture, data model, technology selection, or tradeoff resolution — gets a brief written rationale. When students defend their work at the end of the semester, they are not reconstructing decisions from memory. They are curating a record of their own thinking.

AI and the Cost of Offloading

I want to name this clearly because it gets lost in conversations about academic integrity.

The concern with AI offloading is not primarily that students are cheating. It is that they are forfeiting the experiences that produce the outcomes we most care about.

A student who uses AI to generate their debugging rationale has not practiced the metacognitive regulation that Fink’s Learning How to Learn dimension is built on. They have not developed the habit of monitoring their own understanding and adjusting. They have not had the experience of being genuinely stuck and finding their way through. That experience is not a side effect of learning computing. It is the mechanism by which computing is learned.

⚠️

When we assign AI without designing for visible thinking, we are not just making assessment harder. We are removing the conditions under which the most durable and significant learning occurs.

Getting Started: Three Design Questions

Before assigning any major project, ask yourself three questions.

🧭

1. What thinking do I actually want to see?Name the specific thinking moves from Ritchhart’s list that the assignment should require. Use the Fink-Ritchhart chart to check which Fink dimensions those moves activate. If Human Dimension, Caring, or Learning How to Learn are absent, you have identified your highest-risk area for offloading.

2. Where will that thinking show up in the student’s work?If the answer is “in the final product,” reconsider the design. The final product is where AI performs best. The thinking needs a dedicated, structured space: a routine checkpoint, an annotation layer, a decision log, an oral defense.

3. How will you know it is genuine?Look for specificity. Genuine thinking produces idiosyncratic responses: a named moment of confusion, a connection no one else in the class would make, a question that only makes sense given this student’s prior experience. Generic fluency is the signal that the thinking may have been skipped.

Use the Project Zero Thinking Routine Toolbox to select a routine that fits your course context. It is free, searchable by purpose, and includes facilitation guidance. In most cases, a well-chosen routine adds less than fifteen minutes to the student’s workload and gives you far more information than the artifact alone.

📥

Free resources to go with this post

The goal is not to make every assignment a reflection exercise. It is to build enough visibility into your course design that you can actually see whether the learning you care about is happening.

Because if you cannot see the thinking, you cannot teach it.

And in the age of AI, if you cannot see it, your students may have already learned to skip it.

What thinking routines are you already using in your courses, or curious about adapting for a technical context? Share your approach or questions in the comments.


Read More
Akesha Horton Akesha Horton

Beyond Bloom’s: What Fink’s Taxonomy Means for Computing Courses, AI and Assessments

teacher with a full class of college students discussing AI & Deep Learning

If you have been in higher education for more a while, you have probably encountered Bloom’s Taxonomy: Remember, Apply, Analyze, Evaluate, Create. If you are new or need a quick refresh; review this brief primer.

The cognitive hierarchy that tells you whether you are asking students to think deeply or just recall facts.

Bloom’s is genuinely useful. But L. Dee Fink, in his 2013 book Creating Significant Learning Experiences, noticed something important. Bloom’s only addresses one dimension of how humans learn. It tells you how cognitively demanding a task is. It says almost nothing about whether students will care about it, connect it to anything real, or know how to keep learning on their own after the course ends.

For computing and STEM faculty specifically, this gap has real consequences. We spend enormous energy designing cognitively rigorous assessments and then wonder why students who passed the exam still struggle to function in an internship. Or why a technically strong student falls apart in a team environment. Or why a graduating senior freezes up when asked to learn a new framework on their own.

Bloom’s tells you how hard the thinking is. Fink’s tells you whether it matters to the person doing the thinking.

The Six Dimensions of Fink’s Taxonomy

Fink’s taxonomy is not a hierarchy. It is an interactive web where every dimension strengthens the others. Here is what each one looks like in the context of a computing or STEM course.

DimensionWhat It MeansIn a Computing CourseFoundational Knowledge (FK)Understanding and remembering key concepts, facts, and principlesData structures, algorithm analysis, language syntaxApplication (AP)Critical thinking, creative thinking, practical skills, managing projectsImplementing algorithms, debugging, system designIntegration (IN)Connecting ideas across subjects, disciplines, and life contextsSeeing how OS concepts relate to security; connecting theory to production codeHuman Dimension (HD)Learning about oneself and others, including identity, perspective, and collaborationCode review etiquette, equity in technical interviews, accessibility awarenessCaring (CA)Developing new feelings, interests, and values; becoming genuinely investedCaring about software quality, open-source ethics, end-user impactLearning How to Learn (LL)Metacognition, self-direction, and inquiry skills; becoming a self-improving practitionerReading documentation, developing a debugging mindset, knowing when to ask for help

Why This Matters Right Now

Here is the uncomfortable truth about generative AI and course design. AI is extraordinarily good at Foundational Knowledge. It can explain recursion, walk through a sorting algorithm, or produce syntactically correct code on demand. If your assessments primarily target FK, students do not need to engage with the material. They can simply delegate the work.

But AI cannot learn to care about software quality on your student’s behalf. It cannot develop their debugging mindset. It cannot give them the experience of genuinely connecting theory to a problem that matters to them personally. The upper dimensions of Fink’s taxonomy, specifically HD, CA, and LL, are exactly where human learning is irreplaceable. They are also exactly where most computing assessments underinvest.

The AI Audit

For each of your major assessments, ask yourself: which Fink dimensions does this assignment actually require the student to engage? If you only see FK and AP, and especially if you only see FK, you have found your highest-risk assignment for AI substitution. That is your starting point for redesign. A good place to start is by auditing the verbs you are already using. The Computing Verb Atlas lets you search any verb and immediately see which Bloom’s level and Fink dimensions it activates, making the audit process much faster. [Open the tool.]

Screenshot of the Taxonomy Verb FinderBloom's + Fink's  mapped across both Bloom's Revised Taxonomy and Fink's Significant Learning dimensions for computing and STEM courses.

Practical Examples: Fink in a CS Course

The Difference One Question Makes

Consider a standard data structures assignment: “Implement a binary search tree with insert, delete, and search operations.”

This prompt targets Foundational Knowledge and Application. It misses Integration, Human Dimension, Caring, and Learning How to Learn entirely. It is also almost entirely delegatable to AI.

Now add one question: “Describe a real system you use daily that likely relies on a tree structure. How does your implementation compare to what you would expect in production? What surprised you?”

That one addition requires Integration (connecting BST theory to the real world), Human Dimension (drawing on the student’s own experience), Caring (investment in a system they actually use), and Learning How to Learn (comparing a learning exercise to production reality). AI can generate plausible-sounding text in response to that question. But the student still has to have had the experience to write something genuine.

Caring in a Systems Course

Caring does not mean students have to love your subject. Fink defines it as developing new interests, values, or feelings, including professional values. In a software engineering course, Caring might look like this: Does the student give any thought to writing readable code? Do they consider the next person who will maintain their work? Are they forming a genuine perspective on open-source licensing?

These are not soft skills. They are what separates a developer from a professional.

Learning How to Learn in Every Course

The LL dimension is the most underrepresented in computing curricula and arguably the most important one for long-term career success. The useful life of a specific technology stack is measured in years. The ability to independently pick up a new one is what sustains a career over decades.

What does LL look like as an assessment? It might be a reflection on which resources a student used to solve a difficult problem and why they chose those resources. It could be a post-mortem where students analyze their own debugging process. It can be as simple as asking students to document what they tried before asking for help, making their problem-solving process visible rather than just its final output.

The goal is not students who have learned your course. It is students who know how to keep learning after it ends.

A Note on Integration

A woman stands in front of a white board that has a concept map on it.

Integration is the dimension most likely to shift how a student sees your discipline altogether. It is the moment when a student realizes that the graph algorithms from their CS course are the reason their navigation app works. Or that the ethics discussion in their intro course was not a detour but actually a preview of every technical decision they will make professionally.

Adding Integration to an assignment rarely requires a redesign. It often requires one additional prompt: “How does this connect to something outside this course?” The specificity of the answer will tell you more about a student’s genuine understanding than the code they submitted.

Getting Started: The Fink Audit

Before the next post, try this exercise. Take your next major assignment and map it against the six dimensions. Which dimensions does it genuinely require? Which are completely absent? Then ask yourself: what is the smallest possible change that would add one missing dimension without increasing your grading burden?

References
Anderson, L.W. and Krathwohl, D.R. (Eds.). (2001). A taxonomy for learning, teaching, and assessing. Longman.
ACM Committee for Computing Education in Community Colleges (CCECC). Bloom’s for Computing: Enhancing Bloom’s Revised Taxonomy with Verbs for Computing Disciplines (draft report).
Fink, L.D. (2003). Creating significant learning experiences. Jossey-Bass.

Read More
Akesha Horton Akesha Horton

Don't Judge Me: How I Used Claude & the Real Housewives to Learn to Program

Faculty Development · AI · Real Housewives

Don't Judge Me...
How I Used Claude and the Real Housewives
to Learn How to Program

March 2026
Illustration of a Black woman in cozy loungewear on a couch with a laptop, smiling — a framed portrait of Andy Cohen and a Real Housewife hangs on the wall, stars visible through the window at night.

Let me set the scene.

It's late. I'm supposed to be writing something important. Instead, I'm watching Porsha drag Kenya Moore across my screen, not on Bravo, but inside an interactive network visualization I built myself. In my browser. Using actual code.

I know. I know.

But hear me out, because what happened between me and a D3.js network graph and the entire Real Housewives franchise might just change how you think about learning to program.


I've Been "About to Learn to Code" for Years

I have a Ph.D. I teach faculty how to design courses. I study how people learn. And for years (embarrassingly many years) I could not make programming stick.

I took Python. I understood it in the moment. Two weeks later? Gone. I took a JavaScript tutorial. Same story. I'd get excited, do a few lessons, and then life would intervene and I'd lose the thread entirely.

The Real Problem

The problem wasn't the content. It was that I had no reason to keep going. No project. No stakes. No drama.

Enter: Claude.


The Conversation That Started Everything

I was sitting in on a meeting with a colleague (a genuinely brilliant person who builds interactive educational tools for fun) and he was moving fast. He showed me a network visualization he'd built using something called D3.js and an AI coding tool called Codex. Characters from Game of Thrones were bouncing around the screen, connected by lines showing their relationships. You could drag them. Zoom in. Explore.

It was maybe 300 lines of code. He built it by describing what he wanted in plain English and letting the AI write it.

I thought: I could do that. But with something I actually care about.

And what do I care about? Among other things: the Real Housewives of Atlanta, New York, Beverly Hills, New Jersey, and Potomac. Don't @ me.


What I Actually Did (It's Simpler Than You Think)

I opened Claude and typed, almost verbatim, this prompt:

The Actual Prompt

"Create a simple D3.js network visualization as a single HTML file. Show connections between Real Housewives. I want to be able to drag the nodes around."

That's it. That was the whole prompt.

What came back was a single HTML file with NeNe, Kenya, Porsha, Bethenny, Teresa, and fifteen of their castmates mapped out in a glowing, color-coded, draggable constellation. Each franchise had its own color. Each relationship (friendship, feud, alliance, family, frenemy) had its own line style. Hover over a node and you get the tea. Literally. A little bio pops up.

I double-clicked the file. It opened in my browser. And I sat there for a solid minute just dragging housewives around my screen like a woman who had finally arrived.


But Here's the Part That Actually Made Me Learn

I didn't stop at "ooh, pretty." I started asking questions. Which part of this code is actually about the Housewives, and which part is the instructions for drawing it?

Claude showed me. The answer was two sections: the cast list (readable by any human: you could add a new housewife just by copying a line) and the drama list (relationships, who connects to who). Everything else (the bouncing physics, the color gradients, the hover effects) was D3.js doing the heavy lifting.

Once I understood that, I started poking around. I changed a color. I added a housewife. I broke something, showed Claude the error, and it fixed it while explaining what went wrong. Then I tried to fix the next thing myself before asking.

The Loop That Changed Everything
🛠️
Build something you care about
→
💡
Understand just enough
→
💥
Break it
→
✨
Fix it. Understand more.

What I Actually Learned (For Real This Time)

By End of One Evening
  • What a JavaScript library is and why D3.js exists (it's a pre-built toolbox so you don't have to write the physics of bouncing dots from scratch)
  • What nodes and links are in network visualization (dots = things, lines = relationships, that's it)
  • How an HTML file can contain CSS, HTML, and JavaScript all in one place
  • What it means to declare a variable and store data in it
  • Why GitHub Pages lets you turn a file on your computer into a real website anyone can visit

None of this came from a tutorial. It came from having a specific thing I wanted, building it, and then being curious about how it worked.


The Bigger Thing I'm Sitting With

I study learning. I've spent 15+ years thinking about how people acquire knowledge, what makes it stick, what makes it fall off. And I have to be honest with myself: the approach I just described (interest-driven, project-based, AI-assisted) is exactly what the research says works best.

It's just-in-time learning. You need to know something, so you learn it. You have a reason to remember it because it's connected to something you made.

What AI tools like Claude have changed is the barrier to entry. That's not cheating. That's smart instructional design.


Should You Try This?

Yes. Especially if you've been "about to learn to code" for a while.

My Challenge to You

Think of something you actually care about (a TV show, a research interest, your family tree, your favorite athletes) and ask Claude to build a network visualization of it. Drag the nodes around for a minute. Then ask: "Which part of this code is actually my data?" That question will take you further than any tutorial I've tried.

And Andy Cohen, if you're reading this... can we talk about a collaboration? I'm thinking interactive franchise maps, relationship timelines, reunion drama visualized in real time. I have the vision. I have the AI. I have the love for the franchise.

I'm just not built to be a Housewife myself. The taglines alone would stress me out.

#AIinEducation #LearningToCode #D3js #RealHousewives #FacultyDevelopment #EdTech #GenerativeAI
Akesha Horton, Ph.D.

Director of Academic Engagement and Learning at Indiana University's Luddy School of Informatics, Computing, and Engineering, where she thinks a lot about how people learn, how AI is changing that, and whether Potomac is now better than Atlanta. (It's complicated.) She has 4 degrees. That's Dr. Kesha to you, Sweetie (IYKYK). She is also a Fulbright mtvU alum where she studied the intersection of global citizenship, digital literacies, and hip hop.

Read More