Part 12 of an ongoing series on vibe coding in EdTech.

A while back, I was building a bulk course-enrollment feature for an internal staff chatbot. The idea was simple enough: someone asks the chatbot to enroll a group of people in a Canvas course, and it handles the request instead of a person clicking through each enrollment by hand. Most of the time, that request looks the same. A staff member has a list of names and one course, and they want those people in it.

That is not where my tokens went. I spent most of the build chasing the rare cases: unusual enrollment types, odd course setups, situations that might come up once a year. I pulled in a fair amount of Canvas knowledge base content so the chatbot could handle all of them, and the AI was happy to keep generating code for each new edge case I thought of. What I never did was sit down and map the common case first. When I finally stepped back, the plugin was well built in the sense that a lot of code worked, and poorly designed in the sense that I had spent the bulk of the effort on the one percent while the ninety-nine percent was never clearly drawn out. I ended up rebuilding it from a map, starting with the workflow most people actually needed.

How impressive the code was did not change any of that. As such, the claim of this piece is a plain one: the more of the coding I hand to AI, the more of the design I need to keep for myself.

What didn’t get cheaper?

Part 11 argued that building got cheap while deciding did not, so I will not argue it again here. What I want to add is that the appearance of a finished tool got cheap too. A vibe-coded app can have a clean interface and a long feature list that suggests a lot of thought went into it. Whether anyone actually thought through the problem, the person using it, and how information is supposed to move through it is a separate question. A tool that is lean, solves the problem, does not waste anyone’s time, and is clear for the person using it meets a design standard, not a coding one.

Where does a tool actually live?

Peter Naur, a computer scientist, wrote a short essay in 1985 called “Programming as Theory Building” that has been on my mind since I started handing more code to AI. His argument is that the real product of programming is not the program. Instead, he writes that “programming properly should be regarded as an activity by which the programmers form or achieve a certain kind of insight, a theory, of the matters at hand.” The theory is the understanding of how the program maps onto the world, why each part is the way it is, and how it should change when the world does. Naur goes further and treats documentation as “an auxiliary, secondary product,” something that cannot fully carry that theory on its own.

Naur was writing about professional programming teams, not educators building Apps Script tools, so applying him here is my borrowing. Still, it fits closely. If the AI writes the code and I also skip the design, then nobody holds the theory of the tool. It works until someone needs to change it, and then there is no one who knows why it is shaped the way it is. That matters a great deal in my work, where the tools get handed off to districts who will own them after I am gone. The code travels with the handoff. The theory only travels if someone built it in the first place.

James C. Scott’s idea of metis, which I wrote about in Part 10, comes in here too, again as a borrowed lens. Metis is the practical, local knowledge people build up from doing the work, the kind that rarely makes it into a formal process. When I listen to people describe how they actually do a task before I build anything, I am picking up metis. The design stage is where that knowledge either gets kept in the tool or gets flattened out of it.

Why one set of ideas?

Fred Brooks makes a related argument in The Mythical Man-Month. “I will contend,” he writes, “that conceptual integrity is the most important consideration in system design.” By conceptual integrity he means that a system reflects one coherent set of design ideas. He puts the trade-off bluntly: “It is better to have a system omit certain anomalous features and improvements, but to reflect one set of design ideas, than to have one that contains many good but independent and uncoordinated ideas.”

Brooks gets to conceptual integrity by separating the architect, who decides what the system does for the person using it, from the implementers, who work out how. That split maps onto vibe coding almost directly. I am the architect and the model is the implementer, but only if I actually do the architect’s job. If I do not, each prompt adds one reasonable feature, and after twenty prompts the tool has no center. That is more or less what happened with the enrollment plugin. Every edge case I added made sense on its own, and together they pulled the tool away from what it was mostly for.

This is why ranking matters so much to me now. Before I build, I want to be able to say what the core feature is, what comes second, and what gets cut. If I cannot answer those questions, the AI will not answer them for me. It will simply build whatever I ask for next.

What happens before the diagram?

My actual process is fairly plain, and it is genuinely sequential, so I will lay it out that way. I 1) listen to people talk about the work before proposing anything, 2) open up what I think of as the universe of ideas, asking what the problem actually is and all the ways it could be solved (including, as Part 11 argued, no tool at all), 3) diagram the workflow roughly, 4) rank what is core, 5) jot the big items down as a rough pre-design document, 6) write a more formal design document, 7) go back and forth with Claude on pieces of that document, cautiously, and only then 8) start on code.

The universe of ideas comes from my UX work. I wrote about it in a 2024 case study on applying user research principles to online K-12 professional development, where the research stage changed the direction of the project before any course was built. The certificate I picked up from the Minneapolis College of Art and Design was something I added along the way, and it has turned out to be one of the more durable things I learned. Oddly, the parts that stuck were not the artifacts I expected. Journey maps and user flows still come in, but card sorting, user research methods, and the program’s emphasis on brainstorming and communication are what I actually reach for.

Why does a rough diagram work better?

For mapping a workflow, I use draw.io or one of a few digital whiteboards, and for early conversations the point is simply to have a diagram and share it with people. What I have noticed is that people respond better to a hand-drawn diagram, or something close to one, than to a polished graphic. A rough diagram shows human intention behind it. It also looks unfinished, which invites people to change it, and early on that is exactly what I want them to do.

Claude and plenty of other tools are very good at producing a clean diagram in seconds, and that is part of the problem. A polished diagram looks like a design document. It suggests that thinking happened, whether or not it did, and it can make people less willing to push back because the thing already looks decided.

Fidelity should match the audience and the stage. Rough diagrams belong early and with stakeholders. Higher-fidelity mockups come later, when a team cares more about how the tool looks and how it will be presented than about the technical pieces. I have used Canva for that kind of mockup with some success. Claude’s design tools have been useful for rapid prototyping when there is already a design kit to build from, but they have not fit most of the tools I build.

Who is the design document for?

This is the part I most want the vibe-coding community in education to take seriously. A design document is communication. Eventually it is communication between me and the AI that will write the code, but first it is communication between me and the people the tool is for. For that audience, being overly technical is not useful. What matters is that everyone ends up with the same mental model of the tool, and that each person can see how their piece interacts with it. That is worth more than a document that looks impressive on paper, especially now that anyone can mock up a slick interface with a long list of features.

In that sense, the AI is the last reader of the design document, not the first.

How much design is enough?

There are two tensions here that I have not resolved. The first is that design documents can become their own overhead. Part 11 warned about building tools that cost more to maintain than the problem they solve, and a design process can do the same thing to a small Apps Script tool that a single conversation and a rough sketch would have covered. I do not have a clear rule for where that line sits.

The second comes from Naur himself. If documentation cannot fully carry the theory of a program, then the value of a design document may lie less in the finished document and more in the work of making it. Drawing the diagram is where the theory forms. That is uncomfortable for someone whose job involves handing finished tools to districts, because the part that matters most may be the part that does not transfer. I also still use Claude on parts of the design document, and I am not entirely sure where the line is between help with the writing and handing off the thinking. For now, I keep the sketch for myself and start there.

If you have your own approach to designing before building, or a tool that taught you the hard way, I would like to hear about it. You can reach me at licht.education@gmail.com, and there are more tools, articles, and resources at bradylicht.com.


Discover more from Brady Licht

Subscribe to get the latest posts sent to your email.