Building the APCS Java Dojo
21 Sessions · Concept → Movie Hook → 6 Kata Pages → Full Venue · 2026-11-11–12
How “Wax On, Wax Off” became TNT’s Java muscle-memory venue — and what every prompt can teach you
This is the development diary for the APCS Java Dojo — TNT’s dedicated venue for AP Computer Science A Java fundamentals, built around the Karate Kid “wax on, wax off” principle: reflexive knowledge requires deliberate repetition, not casual reading.
Every session follows the S.P.A.R.K. method: Set goal → Prompt thoughtfully → Analyze the response → Refine → Know & Share. But this log adds one layer you won’t find in most development diaries: every prompt is critiqued using the C.R.A.F.T. rubric — five dimensions of prompt quality, each scored and explained so you can write better prompts yourself.
C.R.A.F.T. in one line: Context • Role • Action • Format • Target — five elements that separate a prompt that gets a vague answer from one that gets exactly what you need.
Look for the blue critique boxes — they are the teaching moments. The amber decision boxes record what was formally decided and why.
Sessions 1–3: Concept & First Builds (08:34–09:28) — Venue concept and 7 theme ideas (A−), Wax On / Wax Off movie clip hook page (A), Dojo home page + styles + chatlog with CRAFT critique framework (A). Four HTML files, two CSS files, two images, one markdown planning document.
Sessions 4–5: Architecture Design (10:20–10:25) — Design consultation: separate vs. blend the kata pages (A — standout role specification). Three-kata cluster architecture finalized: Kata #1 Primitive Arrays, Kata #2 ArrayList, Kata #3 Bridge. The cake-and-eat-it insight (B+) adds the Bridge kata and completes the data-structures cluster plan.
Session 6: Kata #1 Built (10:30) — arraysKata.html + CSS. The Java Motel metaphor, 7 accordion sections, 16-row Quick Reference. Hero image placeholder for user-supplied Java Motel photograph (B+).
Session 7: Kata Explainer Added (11:57) — Working definition of “kata” added to home page with the three-mode study protocol (📖 Learn / 🧪 Review / 🥋 Complete). Best target sentence in the series: “when a user sees arrayKata they know instantly” (A−).
Session 8: Venue Promotion (12:59) — Home page Popular Destinations card added + Resources entry. First AP-Java-specific card in TNT’s 11-year history. JDoodle web-native argument is decisive (A−).
Session 9: Kata #2 Built (15:37) — arrayListKata.html + CSS. PODS metaphor, 8 accordion sections, 23-row Quick Reference. Best build prompt in the series: gap acknowledgment (“add any must-know routines I missed”) added three algorithms (A).
Sessions 10–11: Card Beautification + Kata #3 Built (16:08–16:50) — CrossTraining hero-image card pattern applied to all three kata cards. Design consultation removes “Kata #N” labels from thumbnails (A for the design exchange). Kata #3 Bridge built starring ThreeStoogesDriver; Stooges image for hero and card (A−).
Sessions 12–13: Documentation + Python Connection (17:34–17:38) — Sessions 10–12 logged (B+). Python cross-language section added to Bridge kata (A−) — establishes cross-language sections as a Dojo standard (Decision 16).
Sessions 14–15: Kata #4 Built + This Update (21:01–21:19) — stringsAndCharactersKata.html + CSS. 8 accordion sections, Pinocchio metaphor, Python AND JavaScript cross-language comparisons, the char-array misconception addressed. Richest content specification prompt in the series (A). This session updates the overview and logs Sessions 14–15 (A−).
Session 16 (22:15) — Python string+number concatenation refinement added to Kata #4. The “Is that your honest assessment?” pattern produces the Java Wins Quick-Glue / Python Wins Template Race analysis (A). Decision 19: cross-language sections should show both limitations and strengths.
Session 17 (2026-11-12, 08:44) — Curriculum sequencing design consultation. Pragmatic ordering rationale explained. Loops confirmed before 2D Arrays (dependency argument). Best role-and-context combo of the series (A). Decision 20: Loops → 2D Arrays → OOP.
Session 21 (12:00) — “Extra for Experts” ragged arrays section added to Kata #6. Pascal’s Triangle + Look-and-Say sequence as examples. Five-role specification (mathematician + software developer added). The expert-box CSS callout introduced. Connections to Katas #1–3 bridged explicitly (A).
The APCS Dojo development is a live demonstration of the S.P.A.R.K. method at the project scale — not just the prompt scale. Here’s how the five phases map to what actually happened:
- S — Set Goals: Session 1 is pure goal-setting. TTG didn’t ask for code — he asked for ideas, context, and a tracking document. The goal: a Java review venue with a compelling theme and movie clip hook. That goal shaped every subsequent decision.
- P — Prompt: Each session is a prompt iteration. Session 1 established direction; Session 2 built the first artifact; Session 3 expanded the ecosystem. Notice that each prompt is more specific than the last — a sign of a maturing AI collaborator.
- A — Analyze: The markdown file
apcsPrepReviewIdeas.mdis TTG’s analysis artifact — a running record of decisions, completed work, and next steps. This chatlog extends that analysis into a teaching artifact. - R — Refine: The venue is iterative by design. Four kata pages are now live (Arrays, ArrayList, Bridge, Strings), with Loops next in queue. Each kata was reviewed through the C.R.A.F.T. lens and refined in subsequent sessions — design decisions like the card label removal, the three-mode study protocol, and the cross-language sections all emerged from deliberate refinement cycles.
- K — Know & Share: This chatlog is the K phase. The prompts, decisions, critiques, and reasoning are documented here so students can learn not just what was built, but how and why — and what they would do differently.
You are a web developer, co-creator at TNT and an exceptional computer science teacher who teaches competitive APCS-A in Java. I’ve provided you an overview and snapshot of TNT for reference, as well as some older ‘legacy’ pages I’ve used in my Java classes to help students learn and review the essentials of Java. I’d like to create a venue in our current TNT ecosystem devoted to topical summaries of the keynote issues in Java. In the past, I’ve had ‘ToolTime’ and ‘CrossTraining’ venues that had ‘hooks’ and themes to add whimsy to topics that can be pretty dry. I’m looking for some ideas I can use to form the central theme for this APCS-A prep and review genre. As you know, I often start with a motivational movie clip to introduce such venues. I’m looking for your top 7 ideas I could use for this theming; once we have that in place, we can start revamping the former Java review sheets. Because this is a big endeavor, I’d like to create a markdown file that includes my prompts and your responses so I can give it to you in the future to pick up where we left off. Let’s call that file, apcsPrepReviewIdeas.md. I’m thinking our first task in the review development will be primitive arrays, ArrayLists, the Arrays class, since we are doing that work now. We’ll follow with Strings since they are ubiquitous in CS.
A strong opening prompt that sets the stage effectively — especially in the areas of context and action. The deductions come from three areas where more precision would have sharpened the AI’s output immediately.
✅ What worked well:
apcsPrepReviewIdeas.md before any code exists is exactly right. A reference document requested in Session 1 means every future session can be re-grounded without re-explaining the project.⚠️ What could be stronger:
Key lesson: The best prompt in this batch was the implicit one: asking for ideas before asking for code. That instinct is worth more than any formatting fix. Discuss first, build second.
Read all six attached reference files; created markdownFiles/markdownSpecs/apcsPrepReviewIdeas.md and presented 7 fully developed theme concepts, each with a name, tagline, movie clip hook, central metaphor, concept-to-metaphor mapping, and vibe description:
- 🚀 Mission Control — Apollo 13 (Failure is not an option). Unique tie to TTG’s rocket scientist background.
- ⚔️ The Arena — Gladiator (Maximus’ first entrance). Competitive APCS-A energy.
- 🥋 The Dojo — Karate Kid (Wax on, wax off). Patient mastery through repetition; “Compile. Debug. Repeat.”
- 🔨 The Forge — Thor / How to Train Your Dragon. Maker culture; raw materials become powerful tools.
- 🎮 Power-Up Station — Wreck-It Ralph (collecting the medal). Gamified; each concept is a power-up.
- 🔐 The Vault — Ocean’s Eleven (the full plan revealed). Strategic insiders; Java knowledge is the combination.
- 🏺 The Expedition — Raiders of the Lost Ark (classroom scene). Teacher/explorer duality; most self-aware option for a teacher-led venue.
Personal recommendation given to Mission Control (authentic TTG tie); Dojo and Expedition noted as close seconds. The markdown file was created with all ideas documented plus TNT convention notes for future sessions.
apcsPrepReviewIdeas.md was created in markdownFiles/markdownSpecs/ as the planning spine for this venue. Every future session can load it alongside tntOverview.md and tntSnapshot2026-10-20.md to restore full context. This “hand the AI a document and pick up where you left off” pattern is a professional prompting habit worth establishing immediately on any multi-session project.
- Discuss before you build. The single best use of an AI tool before writing code is asking “what should I build, and what are the options?” An AI that only hears “build me X” will build X. An AI that hears “give me options for X and explain the tradeoffs” will help you make a better decision than you would have made alone.
- Name the analogs. “Like ToolTime and CrossTraining” gave the AI a pattern immediately. When you have prior work in the same ecosystem, name it. The AI can match a template far better than it can invent one from scratch.
- Request the planning document first. Asking for
apcsPrepReviewIdeas.mdin Session 1 means every future session starts with a shared context document. This is not overhead — it is the investment that makes every future prompt more efficient.
Let’s go with the APCS-Java Dojo idea. I have a movie clip showing the famous wax-on wax off scene. Let’s create the movie clip ‘hook’ page: waxOnWaxOffMC.html. I’ve attached a sample movie clip for you to model this new one after. The hero image is supplied. Let’s include a summary of the movie and why this scene was so pivotal. I’m wanting novices to buy into the idea that they have to know the essentials of Java ‘cold’ — there needs to be a sort of ‘muscle memory’ in how they respond to the various big ideas in Java. This venue will provide ‘cheat sheets’ and essential elements of the big ideas of Java as often seen (but not necessarily limited to) the APCS-Java subset. I’ve provided some example pages of Java summaries which are like encapsulated ‘wax-on, wax-off’ ideas. (Pardon the pun). This movie clip page will eventually link to our APCSDojoHome.html page when it is created. The icon for the movie clips page is also attached. Here is the movie clip code: [YouTube iframe embed]. Let’s update our markdown file on this progress.
A well-focused prompt that provides everything the AI needs to produce a finished, deployable file. The jump from “ideas” to “first artifact” is handled correctly: specific file name, model page attached, assets provided, embed code given. No guesswork required.
✅ What worked well:
⚠️ What could be stronger:
Key lesson: The move to “model this after [attached page]” is one of the most efficient format strategies available. A reference page beats a format description every time. If you have a working example, attach it — always.
Completed the full waxOnWaxOffMC.html movie clip hook page, following the agathaAllAlongMC.html pattern with AP Java blue (#5eb3d6) as the accent color. Files created/modified:
movie_clips/waxOnWaxOffMC.html— full page with three <details> sections and YouTube embedimages/Wax-On.jpg— hero image (Daniel and Miyagi waxing a car)images/noun_judo_6346431_676767_@128.png— grid iconmovie_clips.html— new grid entry added at topapcsPrepReviewIdeas.md— Session 2 decisions logged
Page sections: (1) About the Film — full synopsis, Pat Morita’s Oscar nomination, Cobra Kai legacy; (2) The Scene — wax-on chores, Daniel’s frustration, the reveal, two quoted callouts; (3) APCS Dojo Connection — muscle memory argument with three inline kata tables; YouTube embed with AP blue border; “coming soon” link to APCSDojoHome.html in app-link-row.
The judo figure icon (noun_judo_6346431_676767_@128.png) was placed in root images/ and added as the first entry in the movie_clips.html grid, displacing “Agatha All Along” from the top position. This entry also contains the first live reference to the APCS Dojo on the broader TNT site.
The APCS Connection section of the movie clip page includes three compact syntax tables (“the length family,” “element access,” and “sorting”) as a preview of what the Dojo kata pages will contain. These tables do double duty: they make the muscle-memory argument concrete on the movie clip page, and they serve as the prototype format for all future kata content.
I have a folder to house this ecosystem: APCSDojo with sub folders for images, styles, scripts and sourceCode. Let’s create our APCSDojoHome.html with supporting file APCSDojoHomeStyles.css. Let’s begin with a card for the topic of Arrays. I’ve attached a similar home page for other venues I’ve used at TNT so you know the ‘look and feel’ I’m after. We need to use the same hero image as the movie clip on wax on wax off. Also, other venues sport a chatlog for the development. Let’s do that too by creating APCSDojoChatlog.html with an associated styles file: APCSDojoChatlogStyles.css. In the chatlog, include a summary of all the work we’ve done to date (summarize the md file) and include this prompt, and as you have done in other venues, critique and grade my prompts according to our CRAFT mentality for prompting and show how we are using SPARK in our overall development.
The most demanding prompt yet — four files, two CSS sheets, one card, one chatlog with embedded meta-requirements (critique and SPARK analysis). It succeeds because each deliverable is named precisely and the format guidance (reference pages attached) covers the most important unknowns. The deductions are minor.
✅ What worked well:
⚠️ What could be stronger:
Key lesson: Embedding meta-requirements (“critique my prompts according to CRAFT”) inside a build prompt is a powerful pattern. The AI doesn’t just produce an artifact — it produces an artifact that teaches. This is the S.P.A.R.K. K phase built directly into the P phase. That’s a sophisticated prompting move.
Completed all four deliverables for Session 3. Files created:
APCSDojo/APCSDojoHome.html— full venue home page with navbar, back bar, hero (Wax-On.jpg), What section, Kata Collection (Kata #1 active + 2 placeholders), SPARK resources section, footerAPCSDojo/styles/APCSDojoHomeStyles.css— all page-specific styles: hero, back bar, principle cards, kata entry cards, queue items, SPARK link cardsAPCSDojo/APCSDojoChatlog.html— full development chat log with Sessions 1–3, CRAFT critiques, SPARK phase banners, and decision boxesAPCSDojo/styles/APCSDojoChatlogStyles.css— all chatlog-specific styles: bubbles, critique boxes, SPARK banners, session separators
Home page sections: Navbar → Back bar (chatlog link, movie clip link) → Hero (Wax-On.jpg, 62vh, AP blue) → “What is the Dojo?” (7-col text + 5-col principle cards) → “Kata Collection” (dark, 3 cards, queue of 4) → “S.P.A.R.K. & Resources” (5 link cards) → Footer. Kata #1 (Arrays) is active with “Next Build” badge; Strings (#2) and Loops (#3) are placeholder cards. apcsPrepReviewIdeas.md updated with Session 3 work.
The same hero image serves both the movie clip page and the Dojo home page. This creates visual continuity: a student who follows the link from the movie clip page arrives at a home page that feels like the same space. Shared assets are a design pattern worth repeating; they reinforce thematic coherence across a multi-page venue.
Showing placeholder cards rather than a single active card communicates scope and direction without overpromising. Students can see what’s coming. The queue of four additional topics (OOP, Inheritance, Conditionals, Recursion) further signals that the Dojo is a growing venue, not a one-shot cheat sheet. Transparency about roadmap builds trust.
- Movie clip hook page:
movie_clips/waxOnWaxOffMC.html— anchors the venue in pop culture and makes the muscle-memory argument - Movie clips grid entry: top of
movie_clips.html— Dojo discoverable from the main clip catalog - Venue home page:
APCSDojo/APCSDojoHome.html— full scaffolding with Kata #1 card ready - Home page styles:
APCSDojo/styles/APCSDojoHomeStyles.css— AP Java blue design system - Development chatlog:
APCSDojo/APCSDojoChatlog.html— Sessions 1–3 documented with CRAFT critiques and SPARK analysis - Chatlog styles:
APCSDojo/styles/APCSDojoChatlogStyles.css - Planning document:
markdownFiles/markdownSpecs/apcsPrepReviewIdeas.md— full session log, decisions, next steps - Images:
images/Wax-On.jpgandimages/noun_judo_6346431_676767_@128.png
Next build: APCSDojo/arraysKata.html — Kata #1: arrays, ArrayList, and the Arrays class. The kata preview tables already built into the movie clip page serve as the content prototype.
- Kata #1 — Primitive Arrays & the Arrays Class Toolkit (
arraysKata.html) —String[] args, motel metaphor, traversal, common algorithms, DWR warning on SOP printing, Arrays class as superpower unlock. ThreeStoogesDriver as the star example. - Kata #2 — ArrayList & the Collections Class (
arrayListKata.html) — opens with the problem args[] can’t solve; import, generics, wrapper classes, core methods, iteration trap, Collections.sort(). Bridge comparison tables at the bottom. ThreeStoogesDriver as the narrative bridge. - Supplementary — Arrays vs. ArrayList Quick Reference (
arraysQuickRef.html) — exam-day cheat sheet only; comparison tables extracted from waxOnWaxOffMC.html. Not a numbered kata; linked from both kata pages. - Kata #3 — Strings (
stringsKata.html) — builds on the legacy stringResource.html. The Pinocchio metaphor from the legacy page may be worth preserving. - Kata #4+ — Loops, OOP, Inheritance, Conditionals, Recursion — queued; order TBD based on course calendar.
Before we develop our first ‘kata’ page, I want your design opinion as an experienced computer science teacher and educational psychologist. I had originally thought of having a summary ‘kata’ page just featuring ‘primitive arrays’ (along with a discussion of ‘String[] args’) in the main method. Included with that would be a discussion of how to use ‘superpower’ methods from the Arrays class to make manipulations easier of those primitives. I would have had examples of code and common algorithms we might encounter with dealing with primitives. From there, I would have had a separate page for ArrayLists and their connection to Arrays and Collection classes. You blended all of them. Should we stay with this blend or separate them out? Give me pros and cons and let’s include this prompt and analysis in our chatlog. I have included a previous array resource as well as a recent page where we introduced the idea of command line input with the args ‘motel’ in the context of featuring the three stooges.
The standout prompt of the project so far. The role specification is explicit and dual (“experienced computer science teacher and educational psychologist”) — the first time TTG asked the AI to bring a specific disciplinary lens to the analysis. The “before we develop” guardrail is consistent with Session 2 and shows a maturing pattern of holding back implementation until a decision is confirmed.
✅ What worked well:
⚠️ What could be stronger:
Key lesson: This prompt demonstrates the highest-value use of an AI collaborator: a design consultation before a consequential build decision. Building the wrong architecture and then refactoring it costs far more time than pausing to ask “is this right?” first. The student who learns to ask “before we develop — is this the right design?” will be a better developer than one who asks “why isn’t this working?” six sessions later.
Recommendation: Separate — TTG’s original instinct was correct. Here is the core reasoning from both lenses:
From the educational psychologist lens (Cognitive Load Theory, Sweller 1988): Primitive arrays and ArrayLists are genuinely different mental models with different internal representations, different access syntax, different instantiation patterns, and different method vocabularies. Presenting them simultaneously during the learning phase asks students to hold two incompatible paradigms in working memory at the same time. Cognitive Load Theory is unambiguous on this: intrinsic load (the concept complexity) plus extraneous load (the syntax switching) exceeds working memory capacity for most learners. The correct sequence is: master Model A → master Model B → compare them explicitly.
From the CS teacher lens: The AP exam tests them separately. Free-response questions are either array questions or ArrayList questions. Students who drilled them together mix up syntax under pressure — writing list[i] or arr.get(i) — precisely the exam’s most reliable way to forfeit points. The kata is a drill, and a drill should isolate the skill.
String[] args deserves its own section in Kata #1. It is the first array every Java student encounters. It is misunderstood more than any other Java construct (students think it’s just boilerplate). The motel metaphor works perfectly for it — args[0] is Room 0, args[1] is Room 1 — and ThreeStoogesDriver.java is the perfect companion: three named Stooges, three rooms, one fixed-size motel.
The Arrays class as “superpower unlock”: Arrays.sort(), Arrays.toString(), and friends land as revelations only after the student has struggled with raw traversal and the memory-address printing DWR. Present them next to ArrayList methods and they become just more API noise. Present them as the solution to a pain the student just felt, and they become memorable.
The ThreeStoogesDriver becomes the narrative arc, not just an example: In Kata #1, it demonstrates String[] args cold. In Kata #2, it opens with the problem args[] can’t solve: the program needs to grow the cast. The evolution from CODE_1 (three String variables) → CODE_2 (ArrayList that accepts args) in the vibe-code results is the story of why ArrayLists exist.
Kata #1 — Primitive Arrays & the Arrays Class Toolkit (arraysKata.html): Declaration, String[] args with motel metaphor, traversal patterns, common algorithms (min/max, sum, reverse, search), the DWR memory-address warning, Arrays class as superpower unlock (toString, sort, binarySearch, fill, copyOf). ThreeStoogesDriver as central example.
Kata #2 — ArrayList & the Collections Class (arrayListKata.html): Opens with the problem args[] can’t solve. Import, generics, wrapper classes, core methods (add, get, set, remove, size, contains), the remove-while-iterating trap, Collections.sort(). Bridge section at the bottom: comparison tables (.length vs .size(), [] vs .get(), Arrays.sort() vs Collections.sort()). ThreeStoogesDriver as the narrative bridge.
Supplementary — Arrays vs. ArrayList Quick Reference (arraysQuickRef.html): Not a numbered kata. Exam-day comparison tables only, extracted from the movie clip page. Linked from both kata pages. No narrative — just the contrast the student needs 10 minutes before the exam.
The home page Kata #1 card currently reads “Arrays, ArrayList & Arrays Class.” It will be retitled “Primitive Arrays & the Arrays Class Toolkit” and a Kata #2 card for “ArrayList & the Collections Class” will be added. The existing blended description language in the Kata #1 card will be replaced with language specific to primitive arrays and String[] args. This home page update will happen in the next session, after TTG confirms the architecture decision.
- Blended presentations teach comparison. Separated presentations teach mastery. Both have their place. Use separated pages to build the skill from scratch; use blended comparison pages as exam-day references once both skills are independent. Building the reference before the skill is cart-before-horse.
- Your original design instinct is data. When you describe what you originally planned and ask the AI to analyze it, you give the AI a baseline to test against. “I had originally thought…” is one of the most underused sentences in AI collaboration. Use it whenever you want genuine analysis rather than confirmation.
- The “before we develop” guardrail is worth repeating every time. TTG has used it in Sessions 1, 2, and 4. Each time, it prevented a premature build. The cost of pausing to ask “is this design right?” is a few minutes of conversation. The cost of building the wrong architecture is a session of refactoring. The math is obvious. Use the guardrail.
Let’s go with your recommendation and then, what about including a ‘Kata’ where we combine the other two previous ones to show how they all interact? That way we ‘have our cake and eat it too.’
A short, well-timed follow-up that does exactly what a decision-confirmation prompt should do: confirms the prior recommendation and immediately adds value with a creative extension. The grade reflects strong instinct and a good idea, with meaningful room for more specificity that would have produced an even sharper result.
✅ What worked well:
main that uses both String[] args and ArrayList<String> together — gave the AI concrete evidence that the bridge concept was already written in code TTG owns.⚠️ What could be stronger:
arraysBridgeKata.html). Small detail, but naming the file locks the decision and prevents any ambiguity about where the deliverable lives.Key lesson: Short prompts are powerful for confirmations and extensions — but even a short prompt benefits from naming the file and including a documentation request. Those two habits cost one sentence each and they close the loop on every session. The B+ acknowledges the excellent instinct at the cost of the specificity gaps a more experienced prompter would have closed automatically.
Architecture confirmed and extended. The three-kata cluster for arrays/ArrayList now has a complete narrative arc:
- Kata #1 — Primitive Arrays & the Arrays Class Toolkit (
arraysKata.html): Learn the fixed-size motel cold.String[] args, traversal, algorithms, the DWR memory-address warning, Arrays class as superpower unlock. - Kata #2 — ArrayList & the Collections Class (
arrayListKata.html): Learn the expandable hotel cold. Import, generics, wrapper classes, core methods, the remove-while-iterating trap, Collections.sort(). - Kata #3 — The Bridge: Arrays ↔ ArrayList in Action (
arraysBridgeKata.html): ThreeStoogesDriver as the central program — a singlemainusingString[] args(Kata #1) feeding intoArrayList<String>(Kata #2). Conversion patterns (Arrays.asList(),toArray()), side-by-side comparison tables, decision guide for choosing which structure.
Home page updated: Kata #1 card retitled; Kata #2 card changed from “Strings” to “ArrayList” with hotel metaphor; Kata #3 card changed from “Loops” to “The Bridge” with 🌉 emoji. Queue updated: Strings (#4), Loops (#5), Classes & OOP (#6), Inheritance (#7).
The arrays/ArrayList coverage is now three kata pages, not one. Each has a distinct pedagogical role: Kata #1 builds reflexive knowledge of primitive arrays; Kata #2 builds reflexive knowledge of ArrayList; Kata #3 shows them in dialogue. This is the learn separately, then apply together pattern from cognitive science — isolation of skills followed by integration, not simultaneous introduction.
ThreeStoogesDriver.java is the bridge program for the entire cluster. It appears in Kata #1 (demonstrating String[] args), provides motivation in Kata #2 (the problem args[] can’t solve), and is the central example in Kata #3 (showing both in one real program). One program, three teaching moments.
- The “isolation then integration” pattern is a curriculum design principle. Sports coaches use it: practice the serve separately from the rally; then play a game that uses both. Music teachers use it: scales first, then the piece. The three-kata cluster makes this principle explicit in a Java curriculum.
- A “bridge” artifact is not a summary — it’s a new teaching artifact. The bridge kata is not “Kata #1 and Kata #2 combined.” It is a new context that couldn’t exist without both predecessors. The ThreeStoogesDriver makes this concrete: the program is incomprehensible without understanding both the fixed array and the dynamic list.
- Short prompts can produce major architectural decisions. Session 5 was three sentences. It changed the kata count from one to three and established the entire data-structures sequence for the Dojo. The length of a prompt is not correlated with its impact — the quality of the idea is.
Let’s build arraysKata.html and its associate arraysKataStyles.css. I teach my students that arrays are like ‘old-time-y’ ‘motels’ from the 60s and 70s and I have a picture I will supply of a ‘Java Motel’. I like the metaphor of a motel: no frills, set number of rooms, a bit shabby but lets us ‘check people in.’
A clean build prompt that delivers the metaphor content the AI needs and correctly handles the missing hero image with “I will supply.” The grade reflects strong instinct and metaphor richness, with room to add specificity about content scope.
✅ What worked well:
../images/javaMotel.jpg) and use a CSS fallback color. The motel icon from the legacy folder was pulled as an interim asset. The page works immediately and improves automatically when the image is added.arraysKata.html and arraysKataStyles.css named explicitly. No ambiguity.String[] args, motel metaphor, traversal, algorithms, DWR warning, Arrays class. The build prompt could be short because the planning was thorough. This is S.P.A.R.K. working as designed — set goals early, build fast later.⚠️ What could be stronger:
Key lesson: As a project matures and planning sessions accumulate, build prompts can get shorter — because the planning has pre-answered most questions. This is not laziness; it is efficiency. The B+ reflects that the prompt was appropriately compact for this stage while missing two habits (chatlog request, explicit target) that cost nothing to include.
Built APCSDojo/arraysKata.html and APCSDojo/styles/arraysKataStyles.css. Also copied the legacy motel icon (noun-motel-4219007-08A3BD_tbg.png) to APCSDojo/images/ as an interim hero asset while the user-supplied Java Motel photograph is pending (../images/javaMotel.jpg path ready).
Page structure: Navbar → Back bar → Hero (motel image placeholder, AP Java blue) → Overview section with AP Exam Fast Facts card and quick-nav pills + Expand All toggle → 7-section Bootstrap accordion → 16-row Quick Reference table (dark background) → Kata navigation (← Dojo Home | Kata #2 →) → Footer.
Accordion sections:
- 🏨 The Motel Metaphor — conceptual framing with ASCII room diagram and off-by-one DWR
- 📝 Declaring & Building Arrays — three construction forms; default values table
- 🚗
String[] args— command-line motel visual; ThreeStoogesDriver guard pattern - 🔄 Traversal — indexed for vs. enhanced for; when to use each
- 🧮 Common Algorithms — max/min, sum/average, count, fill, reverse
- ⚠️ DWR Warning —
println(arr)memory address trap; char[] exception - ⚡ Arrays Class Toolkit — full method table (8 methods) + live examples
Quick Reference table: 16 rows covering declare, size, access, loops, print, sort, search, fill, copy, compare, import — every row an exam-day essential. Home page Kata #1 card updated to “✅ Available” status.
The hero image is referenced at ../images/javaMotel.jpg. A CSS fallback color (background-color: #0a1a2a) keeps the hero functional until the photograph is added. The existing legacy motel icon (noun-motel-4219007-08A3BD_tbg.png) is copied to APCSDojo/images/ and displayed in the hero as an interim visual. No page changes are required when the photograph is added — just drop javaMotel.jpg into the root images/ folder.
- Kata #1 — COMPLETE:
APCSDojo/arraysKata.html+arraysKataStyles.css - Home page updated: Kata #1 card shows “✅ Available”
- Pending: User to add
images/javaMotel.jpgfor the hero photograph - Next build: Kata #2 — ArrayList & the Collections Class (
arrayListKata.html)
A ‘Kata’ is a new idea to me, it is likely to be new to my novices. Can you frame the idea whimsically into the home page with a working definition so when a user sees ‘arrayKata’ they know instantly what you’re talking about?
An excellent, honest self-assessment prompt: “This is new to me, it is likely new to my novices” is the kind of pedagogical self-awareness that produces great curriculum decisions. The target criterion — “when a user sees ‘arrayKata’ they know instantly” — is one of the strongest target sentences in this project.
✅ What worked well:
⚠️ What could be stronger:
Key lesson: Audience modeling is a prompting superpower. When you explicitly tell the AI who the audience is and what they don’t know, you shift the register of the entire output. “This is new to me, likely new to my novices” is seven words that prevented a jargon-laden explanation from ever being drafted. Use it every time you are writing for an audience that doesn’t share your vocabulary.
Added a styled kata explainer callout to the #dojoKata section of APCSDojoHome.html, sitting between the section heading and the first kata card. Changes made:
- Section label updated: “The Kata” → “The Kata (型)” — kanji appears inline to introduce the concept immediately
- Subtitle updated with gentle invitation: “New to the idea? ↓”
- Kata explainer callout added: styled card with the 型 kanji as a large decorative element, whimsical definition (90-second version), and three clearly labeled modes (Learn it → Review it → Complete it)
- APCSDojoHomeStyles.css: 11 new CSS rules for the explainer, kanji, three-mode layout, and italic punchline
The three kata modes (📖 Learn it / 🧪 Review it / 🥋 Complete it) are the key addition — they tell students not just what a kata is but how to actually use one. A student who reads this before clicking Kata #1 arrives on the kata page already knowing the three-pass study strategy.
The explainer formalizes three distinct ways to engage with a kata page: (1) Learn — first exposure, accordion open; (2) Review — Quick Reference table, self-test mode; (3) Complete — close the page, write from memory. This three-pass model is now the official study protocol for the Dojo and should be referenced in future kata pages, the chatlog, and any student-facing orientation materials. It maps directly to the cognitive science principle of spaced retrieval practice.
Originally, I was going to feature this APCSDojo subdomain in our resources page, but I’m now thinking it should be more prominent, and be featured on our index page as one of our ‘Popular Destinations.’ Every year I have multiple novices learning Java, and since this is a web-based venue, I’ve not always had a lot to offer them, until now, when we can copy code and then test it at places like JDoodle. That said, what are the pros and cons of offering a APCSDojo card on the home page (and also in resources) or, just offering it in a lower profile place like resources. Let’s discuss this in our chatlog and then make a final determination.
An excellent discussion prompt that arrives with new context (the JDoodle angle), states both options explicitly, specifies the format (chatlog), and sets a clear outcome target (final determination). The weaknesses are minor.
✅ What worked well:
⚠️ What could be stronger:
Key lesson: Surface new evidence when the landscape changes. The JDoodle / web-native Java argument was the strongest card in the hand and was held until this session. If TTG had mentioned it in Session 1 when the venue concept was first discussed, the home page target might have been baked in from the start. When you have new evidence that changes the case, say it explicitly — don’t assume the AI has figured it out.
Finding from examining index.html and resources.html: The home page currently has 10 Popular Destinations cards (Ask Copilot, Image Gallery, Adventures, Creative Cross Training, Cross Training, SketchWave, Tool Time, See the Code, SPARK Speeches, Legacy Archive). Of these, not one is AP-Java-specific. Foundation students have SketchWave and Creative Cross Training. Innovations students have See the Code. AP Developer Studio — Course 03, the summit of the three-course sequence — has zero dedicated home page representation.
Determination: Both — with home page as primary.
Strongest argument for home page: The JDoodle / web-native Java argument is genuinely new and genuinely strong. Prior Java resources were IDE-locked — useless without an installation, limiting classroom utility to students who had already set up their development environment. Kata pages with copy-to-JDoodle make them usable on any device in any classroom without installing anything. That is a capability worth headlining. The AP Java course runs all year. The home page serves students 12 months a year. The “half-built” concern is solved by the established badge pattern (“🥋 Kata #1 Live!” in AP Java blue) — identical to how Adventures says “🗺️ Live!” while still building.
Resources concern: The res-tnt accordion section holds utilities (DWR, Gallery, Code Word Collector) and archives (Past Blasts). The Dojo is a fully-developed teaching venue — it belongs there as a secondary discovery path, not as the primary home.
Feature card added after Tool Time: AI Edition in the Popular Destinations grid. Background: images/Wax-On.jpg (consistent with the venue’s hero image). Badge: 🥋 Kata #1 Live! in AP Java blue (#1a5c8a). Description acknowledges the growing nature of the venue. This is the first AP-Java-specific card on the TNT home page in the site’s history since 2015.
Resource card added as the first entry in the res-tnt accordion section of resources.html. AP Java blue icon (fas fa-hand-fist). Description explicitly mentions JDoodle and the web-native use case — the strongest selling point for this audience. Students who arrive at resources looking specifically for AP Java reference material will find it at the top of the TNT-built resources section.
- Surface new evidence the moment it changes the analysis. The JDoodle / web-native argument was the decisive factor in this session. It wasn’t present in Sessions 1–7. When something changes the case, say it immediately in the prompt body — don’t assume the AI already knows.
- Resources ≠ home for first-party venues. Resources pages are designed for curated external links and utility tools. A fully developed teaching venue with its own home page, kata pages, chatlog, and hero image is a first-class site citizen — it deserves a first-class discovery path.
- The “half-built” concern has a TNT-native solution. The badge pattern (“Live!”, “On the Air”, “Growing!”) already exists on the home page for exactly this purpose. Never let incomplete state prevent a launch — label it honestly and let the audience self-select.
I am very pleased with our arraysKata. Based on this example, let’s create one for ArrayLists, as we mentioned in our planning: arrayListKata.html with associated arrayListKataStyles.css. The idea here is that we can have storage ‘rooms’ that we can add, remove, and re-arrange. Traditionally, I think of them as ‘Pod’ storage units that can be chained together. I have attached a thematic image for our hero. I also have a previous page that showcases ArrayLists. I’d like to include discussions of how Collection class methods can be used in conjunction with ArrayLists to do typical tasks. You’ll notice I have some common ‘Helpful’ ArrayList Manipulations in the legacy document. Those can be included as you did with the arrays in the ‘Common Array Algorithms.’ We’d just have a ‘Common ArrayList Algorithms’ instead. I’m sure I’ve failed to include some important ones: add any that are ‘must know’ type routines. Remember our next kata will be to show the interaction of the two data structure venues, arrays and ArrayLists, so we can save the algorithms that work on both for that venue. Please add this development, prompt, critique, grade and analysis to our chatlog.
The strongest build prompt in the series. Five reference files attached, a thematic hero image supplied, specific content requirements stated, a scope boundary drawn (“save algorithms that work on both for Kata #3”), and an explicit request for additions (“add any must-know routines I missed”). The chatlog update request returned, which had been missing for three sessions.
✅ What worked well:
⚠️ What could be stronger:
list.size() (not .length), list.get(i) (not list[i]), and all three DWR traps cold” would have been a useful target sentence.Key lesson: Delegation with acknowledgment is a prompting superpower. “I’m sure I missed some important ones — add any must-know routines” is seven words that invited the AI to contribute expertise rather than just execute instructions. The result was six algorithms instead of the four from the legacy page. Knowing what you don’t know and asking for it explicitly is a sign of a maturing AI collaborator.
Built APCSDojo/arrayListKata.html (66KB) and APCSDojo/styles/arrayListKataStyles.css (12KB). Hero image images/pods-driveway-min.webp confirmed in place. Home page Kata #2 card updated to “✅ Available.”
8 accordion sections:
- 🏗️ The PODS Metaphor — dynamic vs. fixed with ASCII pod lineups showing add/remove/shift
- 📝 Declaration, Construction & Initialization — import, three-step build, diamond syntax, println() works!
- 🧪 Generics & Wrapper Classes — why Integer not int, autoboxing, wrapper badge row
- 🔄 Traversal — indexed for (.get() and .size()), enhanced for, ConcurrentModificationException warning
- 🧰 Core Methods — full 12-method table (add, get, set, remove×2, size, contains, indexOf, lastIndexOf, clear, isEmpty)
- 🧮 Common ArrayList Algorithms — add without duplicates, remove all instances (safe backward loop), find max/min, count occurrences, remove last, build from String, remove duplicates (LinkedHashSet), sum/average
- ⚠️ DWR Warnings — remove(int) vs remove(Object) Integer trap, ConcurrentModificationException, ArrayList<int> compile error
- ⚡ Collections Class Toolkit — 9-method table (sort, reverseOrder, reverse, min, max, frequency, shuffle, addAll, nCopies) + live examples
Quick Reference: 23-row exam-day table covering all operations. Added beyond legacy: remove duplicates via LinkedHashSet, sum/average, nCopies, lastIndexOf, reverseOrder sort, Collections.frequency vs. manual count. Saved for Kata #3: conversion patterns (array↔ArrayList), side-by-side comparison tables, algorithms that apply to both structures.
Kata #1 (Primitive Arrays) and Kata #2 (ArrayList) are both live. Kata #3 (The Bridge) is the next build: ThreeStoogesDriver as the star program, conversion patterns between arrays and ArrayList, and the side-by-side comparison tables that belong in context rather than on a standalone cheat sheet. The home page now shows two active kata cards and one placeholder.
Each Kata will have its own thematic hero image; let’s ‘dress up’ the cards on the dojo home page with hero background art and put the thematic icons next to the heading of the card. We use this idea in the CrossTrainingHome.html page. Let’s do it on the APCSDojoHome page as well.
✅ What worked well:
.ct-entry-thumb-bg and .ct-entry-header pattern exactly.Do you think the labels of ‘Kata #x’ take away/detract from the pictures?
Yes — and here’s why. The CrossTraining reference used empty thumbnails: pure image, no text overlay. The “Kata #N” badge floats over the image’s visual focal point, which splits attention before the image has a chance to do its work. The fix: pull the number off the thumbnail and fold it into the concept label line (“Kata #1 · Data Structures · Java”) — the same technique CrossTraining uses with “Concept #1.” The thumbnail becomes clean art; the number lands naturally where the reader expects information.
Yes, I agree. Change it. I don’t want the distractions.
Prompts 10b and 10c together form a perfect design consultation exchange. 10b asks for a genuine opinion — not “can you do X” but “should we do X?” — which is S.P.A.R.K. A (Analyze) applied to a visual decision. 10c is a clean decision: six words, zero ambiguity. The design consultation pattern (ask for opinion → receive reasoning → decide) is worth internalizing as a workflow.
Kata cards follow the CrossTraining pattern: thumbnails show only the background image (at 28% opacity, scaling to 52% on hover). The kata number moves into the concept label line (“Kata #1 · Data Structures · Java”). The .dojo-entry-num CSS rule was removed entirely. Thematic icons (🏨 🏗️ 🌉) moved into the .dojo-entry-header flex row beside the title, matching .ct-entry-icon. This design principle — thumbnails are visual hooks, not label carriers — applies to every future kata card.
Let’s make the 3rd card and since our stooges vibe code app uses command line prompts, primitive and ArrayLists, let’s showcase it along with other necessary information within that card. Use the stooges hero pic for the card pic as well as for the hero page for the 3rd Kata card.
An efficient build prompt that lands its key pedagogical insight in one sentence: the ThreeStoogesDriver is the right star for the Bridge kata because it uses both structures in a single program. Attaching the vibe-code results page gave the AI the content and the narrative arc.
✅ What worked well:
threeStoogesVibeCodeResults.html — the page that documents all four vibe-coding iterations of the program. The AI could trace the program’s full evolution (STRING variables → ArrayList) and use it as the narrative arc for the Bridge kata.⚠️ What could be stronger:
Key lesson: Prior planning is the most efficient form of context. This prompt was short because Sessions 4, 5, and the planning discussions had already answered its key questions. The kata’s content, structure, star program, and scope boundary were all decided before a line of code was written. This is S.P.A.R.K. working at the project scale: invest in the S and A phases, and the P phases get dramatically shorter.
Built APCSDojo/arraysBridgeKata.html (44KB) and APCSDojo/styles/arraysBridgeKataStyles.css. Hero image: The-Three-Stooges-Moe-Howard-Larry-Fine.webp (confirmed in root images/). Home page Kata #3 card activated — zero placeholder cards remaining. All three kata cards show ✅ Available.
6 accordion sections: (1) The Bridge concept — why the two structures collaborate; (2) ThreeStoogesDriver walkthrough — full annotated program, spotlighting hasDuplicates() (pure array syntax) vs printStooges() (pure ArrayList syntax) vs main() which crosses the bridge; (3) Array → ArrayList — three conversion patterns with the Arrays.asList() fixed-size DWR; (4) ArrayList → Array — two patterns with the Object[] type-loss DWR; (5) Side-by-Side comparison — 15-row table, every syntax pair that matters; (6) Decision Guide — two decision tables and the one-question test (“Does the size change?”).
Quick Reference: 9-row bridge table including the conversion syntax rows that cannot appear on either of the first two kata pages. Card description showcases ThreeStoogesDriver by name, linking it to Tool Time Entry #6.
Kata #1 (motel / primitive arrays), Kata #2 (PODS / ArrayList), and Kata #3 (the Bridge / both together) form a complete, self-contained data-structures cluster. Each has its own thematic hero image, metaphor, accordion sections, and exam-day Quick Reference. ThreeStoogesDriver serves as the bridge program in Kata #3 and is cited in both the kata page and the home page card. The three-kata cluster is the largest finished unit in the Dojo; Kata #4 (Strings) is next.
Let’s update our chatlog with the last prompt, and this one, as we made the Kata#3 about the bridge between primitive arrays and ArrayLists.
A clean meta-prompt: its purpose is to restore documentation, and it does so concisely. The “last prompt, and this one” scope instruction is clear. The context clause (“as we made the Kata #3 about the bridge”) explains what this documentation covers — useful for future readers who load this chatlog from the markdown file and need quick orientation.
✅ What worked well:
⚠️ What could be stronger:
Key lesson: Documentation debt is real, and it’s worth repaying promptly. A chatlog that falls two sessions behind is still recoverable. A chatlog that falls ten sessions behind has lost the specific decisions, reasoning, and teaching moments that make it valuable. The habit of ending every session with “update the chatlog” costs one sentence and prevents the debt from accumulating.
With Session 12, the first major content cluster of the APCS Java Dojo is fully built and documented:
- ✅ Kata #1 — Primitive Arrays & the Arrays Class Toolkit (
arraysKata.html) — motel metaphor - ✅ Kata #2 — ArrayList & the Collections Class (
arrayListKata.html) — PODS metaphor - ✅ Kata #3 — The Bridge: Arrays ↔ ArrayList in Action (
arraysBridgeKata.html) — ThreeStoogesDriver - ✅ Movie clip hook — Wax On, Wax Off (
movie_clips/waxOnWaxOffMC.html) - ✅ Venue home page — with kata explainer, all three cards live, queue visible
- ✅ Home page card — “🥋 Kata #1 Live!” in Popular Destinations
- ✅ Resources entry — in TNT’s Own Resources
- ✅ News entry #095 — first AP Java venue in TNT’s 11-year history
Next: Kata #4 — Strings & the String Class.
For our Python users, how would you compare and contrast Pythonic ‘lists’ with arrays and ArrayLists? In fact, let’s add this observation as a footnote in our Kata bridge page #3. I want novices to make as many cross-language connections as they can!
A short, well-motivated prompt whose strongest element is the target sentence. “I want novices to make as many cross-language connections as they can” is a pedagogical design principle that shaped every content decision in the resulting section — the three-column table, the sys.argv parallel, and the bottom-line bullet points are all expressions of that goal.
✅ What worked well:
append() for add()”), not as new knowledge, which is exactly the right approach for students who already have Python fluency.⚠️ What could be stronger:
<aside> at the page bottom. “Add it as a collapsible section at the bottom of the main accordion” or “add a small cross-language callout box after the Decision Guide” would have made the format choice explicit. As it stands, the full section is probably the right call pedagogically, but TTG should have made that call, not the AI.Key lesson: “Make cross-language connections” is a reusable pedagogical directive. It could apply to the Strings kata (Python strings vs. Java Strings), the Loops kata (Python range-based for vs. Java enhanced for), and the OOP kata (Python self vs. Java this). Consider making this directive part of every future kata build prompt — a standing instruction that shapes content without requiring a separate session.
Added Section 07 — 🐍 Python Connection as a full accordion section at the end of arraysBridgeKata.html, and added .python-callout (green-tinted, left-bordered) to arraysBridgeKataStyles.css. Quick nav updated with a 🐍 Python pill.
Section content:
- Green
.python-calloutintro: Java ArrayList ≈ Python list; Java primitive array has no clean Python equivalent - Three-column comparison table (Java Array | Java ArrayList | Python List) across 15 operations: import, create, size, read, write, add, insert, remove last, remove by value, membership check, find index, sort, print, mixed types, dynamic size
sys.argvvs.String[] argscode block — with the key gotcha: Python’ssys.argv[0]is the script name; Java’sargs[0]is the first user argument. Same three-stooge program needslen(sys.argv) >= 4in Python butargs.length >= 3in Java.- Bottom-line bullets: swap
append()→add()andlen()→size()and you’re most of the way there; Java arrays are closer to Python tuples than Python lists; Java is strictly typed;x in listis Python’s most elegant win.
The Python Connection section in Kata #3 establishes a pattern: each kata should include a cross-language sidebar for students traveling from Python (or JavaScript). The TNT ecosystem already has Cross Training venues for this purpose; the Dojo kata pages can be the AP-Java-specific entry point. Future katas should include equivalent notes: Python str vs. Java String in Kata #4 (Strings), Python range-based for vs. Java enhanced for in Kata #5 (Loops), Python classes vs. Java classes in Kata #6 (OOP).
We have three successful Kata’s featuring arrays, ArrayLists and a ‘bridge’ between the 3. Let’s now feature a Kata on Strings. In my view it’s very important and many examples should be provided showing the relationships between Strings, characters, the Character class and even arrays since sometimes Strings are perceived as arrays of characters in Java. (not true?!). As we did with the bridge Kata, let’s feature the connection between Strings in Java and strings in Python. Let’s also add another section about Strings in JavaScript! I’ve provided a hero image for our hero area and the card on the home page. In the past I’ve often used the idea of Pinocchio and Strings as a goofy way of creating examples to showcase the ideas about String manipulation. I’ve included my past legacy summary page about Strings. Follow the examples of the other Katas in making this one, stringsAndCharactersKata.html and its associated stringsAndCharactersKataStyles.css.
The strongest build prompt of the project. Every C.R.A.F.T. element is present, the content requirements are the most specific of any session, and TTG explicitly flagged a teaching trap (“not true?!”) that became a cornerstone of the kata’s opening section.
✅ What worked well:
s.length vs s.length() trap is now documented for the first time.stringsAndCharactersKata.html and its CSS named explicitly. The plural name signals that chars and the Character class are first-class citizens, not footnotes — a good content decision embedded in the filename choice.⚠️ What could be stronger:
Key lesson: The “not true?!” pattern is powerful prompting. When you flag a common misconception as a question mid-prompt — “sometimes Strings are perceived as arrays of characters (not true?!)” — you turn a potential ambiguity into a teaching directive. The AI doesn’t just mention the misconception; it devotes an entire section to correcting it with examples, code, and a DWR box. Any time you have a misconception you want students to avoid, embed it this way.
Built APCSDojo/stringsAndCharactersKata.html (63KB) and APCSDojo/styles/stringsAndCharactersKataStyles.css (11KB). Hero image images/aiRobotNoStrings.png (AI robot + Pinocchio: “No strings attached!”) copied to root images folder. Home page Kata #4 card added (4 ✅ Available badges total). Bridge kata “Kata #4” navigation link wired to stringsAndCharactersKata.html.
8 accordion sections:
- 🪡 The Pinocchio Metaphor — Strings as objects, immutability, and the definitive answer to “are Strings char arrays?” (No. Loaf ≠ slice.)
- 📝 Declaration — direct, constructor, empty vs. null, three ways char→String, from char array, concatenation and the accumulator pattern
- 🔡 chars & Character Class — single vs. double quotes, char arithmetic, full 9-method Character class table
- 🧰 Core Methods — 21-method table with Pinocchio examples throughout
- ⚠️ DWR Warnings — 5 traps:
==vs.equals(), immutability discard,substring()exclusive end, null NPE,str[i]compile error - 🧮 Algorithms — reverse, count chars, palindrome, count vowels, titleCase, remove spaces
- 🐍 Python Connection — 16-row comparison; 3 Java traps Python hides from you
- 🌐 JavaScript Connection — 17-row comparison; the
s.length(no parens) vss.length()(parens) trap headlined
Quick Reference: 25-row exam-day table. Queue updated: Strings removed, Loops moves to #5, Classes to #6, Inheritance to #7, Conditionals to #8.
Starting with Kata #4, the cross-language section now covers three languages: Java, Python, and JavaScript. The JavaScript connection is especially valuable for TNT students who have worked through CS Innovations Studio (Course 02) before AP Developer Studio (Course 03). Future katas should include the JS column wherever the syntax is meaningfully different — especially Loops (Python range/for vs. Java enhanced for vs. JS forEach/for...of) and OOP (Python self vs. Java this vs. JS this quirks).
Our chatlog summary/overview needs updating and we need to add in our recent inclusion of Kata #4 on Strings (also include this prompt) along with all critiques, prompt ‘grades’ and your analysis.
A clean meta-prompt that correctly identifies three separate tasks: update the overview, add Session 14, add Session 15. The “also include this prompt” clause is a reflexive documentation habit that returns for the first time since Session 9.
✅ What worked well:
⚠️ What could be stronger:
Key lesson: Documentation prompts are highest-value when they are most specific. A meta-prompt that says “update the overview summary to reflect all 15 sessions, update the back-bar and hero subtitle counts, refresh the SPARK R bullet, and add Sessions 14–15 with full CRAFT critiques” leaves nothing to inference. The best documentation prompts treat the chatlog as a deliverable with explicit specifications — just like a build prompt treats the HTML page.
Updated four elements in the chatlog header area: back-bar span (Sessions 1–3 → 1–15), hero subtitle (description now reflects the full 15-session arc), About This Log overview (now summarizes all sessions in grouped paragraphs), and SPARK R bullet (updated to reflect four live kata pages). Added Sessions 14 and 15 with full CRAFT critiques, grades, and analysis.
Grade summary across all 15 sessions: A− · A · A · A · B+ · B+ · A− · A− · A · A−/A/B · A− · B+ · A− · A · A−. Trend: prompt quality improved significantly from Sessions 1–3 to Sessions 9–14. The two most reliable indicators of a high-grade prompt: (1) reference files attached for context and format, (2) a specific target sentence stating the desired student outcome.
Across 15 sessions, the documentation habit drifted in Sessions 7–8, 11, and 14. Each drift required a catch-up session. The correct pattern — demonstrated in Sessions 1–6 and 9 — is to end every build prompt with “add this session to the chatlog.” The cost: five words. The benefit: continuous documentation that accurately reflects the project state without requiring a dedicated catch-up session.
- ✅ Movie clip hook:
movie_clips/waxOnWaxOffMC.html - ✅ Venue home page:
APCSDojo/APCSDojoHome.html— 6 live kata cards - ✅ Kata #1 — Primitive Arrays:
arraysKata.html - ✅ Kata #2 — ArrayList:
arrayListKata.html - ✅ Kata #3 — The Bridge:
arraysBridgeKata.html - ✅ Kata #4 — Strings & Characters:
stringsAndCharactersKata.html - ✅ Kata #5 — Loops & Iteration:
loopsKata.html - ✅ Kata #6 — 2D Arrays:
twoDArrayKata.html— duck grid; AP grader DWRs; +Extra for Experts: ragged arrays (Pascal’s Triangle, Look-and-Say) - ✅ Development chatlog:
APCSDojoChatlog.html— 20 sessions - ✅ Home page card; Resources entry; News entry #095
- 🔜 Next: Kata #7 — Classes & OOP Fundamentals
In the Python section, you mention how strings can ‘concatenate’ with + Let’s mention, for contrast, how you must cast a numeric value as a string to ‘glue’ a phrase together like “My age = ” + str(15)” rather than how you could do it with Java as: “My age = ” + 15 without casting. Also mention with an example how we can also use a string formatter in Python to avoid casting. It is, however, a place where Python is more cumbersome than Java. Is that your honest assessment too? Let’s discuss this in our chatlog too.
An excellent refinement prompt with a distinguishing feature: “Is that your honest assessment too?” invites a genuine opinion, not cheerleading. This is a sophisticated prompting move — asking the AI to evaluate a premise rather than simply execute it. The result is a more nuanced, defensible answer than the prompt would have received without that question.
✅ What worked well:
"My age = " + 15) and the Python cast version ("My age = " + str(15)) were written out. This eliminated any ambiguity about what the content should show and produced exactly the right code example.⚠️ What could be stronger:
Key lesson: “Is that your honest assessment?” is one of the best sentences in the AI-collaboration vocabulary. It signals that you want genuine analysis, not agreement. It prevents the AI from simply validating whatever frame you set. Use it whenever you’re about to make a comparative claim and want to know if it holds up. The best version of this prompt asks for the strongest counterargument: “Push back if you think this framing is unfair to Python.”
Yes — and also no. Here’s the full picture:
Java wins the quick-glue race. "My age = " + 15 works in Java without a cast. Java automatically coerces the numeric to a String when it sees String + anything. For a one-liner quick print or string build, Java is objectively less verbose.
Python wins the template race. The moment your string involves more than one or two values, Python f-strings are more readable than Java’s concatenation chain: f"I am {name}, age {age}, born in {year}" vs "I am " + name + ", age " + age + ", born in " + year. For real programs with real strings, Python f-strings are the superior tool.
Java’s implicit coercion is a double-edged sword. "Result: " + 1 + 2 produces "Result: 12", not "Result: 3" — because Java processes left-to-right and the first + triggers string concatenation mode for the rest of the expression. This surprises beginners. Python’s explicit cast requirement prevents this entire class of bug.
Bottom line: “More cumbersome” is accurate for the specific, common case of string + number. It is not an accurate summary of Python string handling overall. The kata page reflects this nuance: the callout is titled “Java Wins the Quick-Glue Race; Python Wins the Template Race.”
Session 16 establishes a principle for all future cross-language sections: when noting a limitation in one language, also show the other language’s limitation or the offsetting strength. Java’s implicit coercion is convenient and can produce surprise results. Python’s explicit cast is cumbersome for simple cases and produces cleaner complex templates with f-strings. Presenting only one side of a trade-off produces unbalanced cross-language comparisons that mislead novices.
You may be wondering why I began with Kata#1 with Arrays. If you look at my previous AP Review sheet, you notice I started with preliminaries and worked my way up to arrays, ArrayLists, 2D arrays, etc. The reason I started with arrays was pragmatic: this is a new facet of TNT training and we are currently learning about arrays, so I decided to start with something I could actually start using. I think this perspective is important and think it might be good to draw a novice’s attention to it, but I’d like your opinion. Either way, for the next Kata: I could go with 2D arrays or, you had suggested Iteration/Looping. What are the pros and cons of going with either one? We can discuss this and then decide on our next steps. Please write these considerations up in our chatlog and markdown file, along with typical prompt critiques and grades.
An excellent design consultation prompt. TTG explains his own reasoning, asks for a genuine second opinion on two separate questions, and correctly defers the build decision to after the discussion. The documentation request is included. Eight reference files are attached.
✅ What worked well:
apcsTestReview.html which shows the original sequence (Language → I/O → Booleans → Iteration → Classes → Arrays). The AI can compare the original intended sequence against the Dojo’s actual sequence and reason about the gap. This is the most informative context attachment in the project.⚠️ What could be stronger:
Key lesson: Self-explaining your own reasoning is one of the most underused prompting moves. When you tell the AI why you made a past decision, you enable it to evaluate the reasoning, not just the result. “I started with Arrays because we were studying them” produces a richer analysis than “I started with Arrays.” The first version allows the AI to validate, challenge, or extend the rationale. The second version leaves the AI to guess.
On the pragmatic ordering — should novices see this?
Yes, with a light touch — and in the right place. The Dojo home page and kata pages should feel purposeful and confident, not apologetic. The chatlog is exactly where this reasoning belongs: it is the K phase of S.P.A.R.K., and the meta-transparency about curriculum decisions is precisely what makes the TNT development process educational. A note in the chatlog’s overview section (“the Dojo katas are ordered pragmatically: we started where the class was, not where a textbook would start”) honors the real-world origin without cluttering the student-facing pages. If anything, it teaches a valuable lesson: good curriculum meets students where they are, not where the textbook assumes they should be.
The legacy sequence vs. the Dojo sequence: The original apcsTestReview.html proceeds: Language Fundamentals → I/O → Booleans → Iteration → Classes → Arrays → ArrayLists → Strings. The Dojo inverted this sequence, starting with Arrays → ArrayList → Strings, skipping the prerequisite infrastructure (Iteration, Booleans, Classes). That inversion was justified pragmatically — build what’s immediately useful. Kata #5 is the natural correction point.
2D Arrays vs. Loops — Recommendation: Loops first.
The dependency argument is decisive. Every meaningful 2D array operation — filling a grid, traversing rows and columns, finding max/min across a 2D structure, summing rows — requires a nested for loop. The Dojo’s Arrays kata already teaches single-loop traversal; a 2D Arrays kata without a dedicated Loops kata would need to teach nested loops inside the kata itself, defeating the kata model of one concept per page. Loops first removes that dependency entirely and makes 2D Arrays dramatically easier to present.
Additionally: loops appear in every APCS-A free-response question set. 2D arrays appear in one standard FRQ type. AP exam impact per study hour favors Loops by a wide margin.
Recommended sequence forward: Kata #5 (Loops/Iteration) → Kata #6 (2D Arrays, with nested loops now in the toolkit) → Kata #7 (OOP/Classes) → Kata #8 (Inheritance/Polymorphism).
Next kata: Loops & Iteration (Kata #5). Dependency argument is decisive: 2D array traversal requires nested loops, which haven’t been covered as a primary kata topic. Loops first; 2D Arrays as Kata #6.
Pragmatic ordering note: The rationale for starting with Arrays (currently teaching it, immediately useful) is documented here in the chatlog and in the markdown planning file. It is not added to the student-facing home page — the kata pages should feel purposeful. The chatlog is the right home for curriculum reasoning.
The APCS Java Dojo does not follow a textbook sequence. A conventional Java curriculum introduces language fundamentals, then I/O, then conditionals, then loops, then arrays. The Dojo started with arrays — the structure the class was actively studying when the venue was created. This was a deliberate pragmatic choice: build what’s immediately useful, deploy it while students need it, fill in the prerequisite concepts as the venue grows.
This is not a flaw; it is a feature. The Dojo is a living curriculum artifact. Each kata was built in response to real classroom need, not in response to a predetermined table of contents. Students and teachers reading this chatlog can see that decision explicitly: start where you are, build what you can use, sequence toward completeness over time. This is S.P.A.R.K. applied to curriculum design.
We have 4 successful Katas. We’ve decided to focus on ‘Loops’ (aka Iteration) for our 5th. I’ve included a playful ‘hampster wheel’ as a way of envisioning something that’s running in the background (feel free to suggest a better image/genre if you think of one!). You are a web designer, experienced APCS teacher and grader and a co-designer at TNT. We want a Kata page to capture the essentials of loops in Java. We’ll follow the same patterns as the other Kata pages and show how loops work in Python and JavaScript as well. Because novices will have seen and learned about arrays and strings, use those as primary devices in building up the ideas of looping. Of course, we need to address the dreaded ‘infinite loop’ and the ‘break’ as a way of stopping a ‘runaway train.’ Include any common algorithms that are ‘must know’ regarding loops. I have included my former review that had my (limited) summary of loops. Draw on that but it needs to be extended.
The strongest build prompt of the entire project. All five C.R.A.F.T. elements are present, the role specification is the most complete in any session, and the content requirements name specific teaching emphases rather than generic coverage. The image feedback invitation is an excellent Format move rarely seen in novice prompting.
✅ What worked well:
apcsTestReview.html (loops section), all existing kata pages (format blueprints), the markdown file, and the hero image. Complete context delivery.⚠️ What could be stronger:
Key lesson: The triple-role specification is the most underused technique in the series. “You are a web designer, APCS teacher, and TNT co-designer” produces qualitatively different output from either role alone. The web designer prevents bad HTML patterns; the APCS teacher enforces exam-relevant emphasis; the co-designer ensures venue consistency. When a task genuinely spans multiple disciplines, name each one explicitly rather than letting the AI default to one lens.
On the image: The hamster wheel is the right choice — keep it. It captures loop repetition, the necessity of a stopping condition, and the infinite-loop hazard better than a runaway train (which is one-directional). The hamster is also more whimsical, which fits the Dojo’s tone.
Built APCSDojo/loopsKata.html (54KB) and APCSDojo/styles/loopsKataStyles.css (11KB). Hero image images/hampsterWheel.jpg copied to root images folder. Home page Kata #5 card added (5 ✅ Available badges). Strings kata navigation wired to loopsKata.html.
9 accordion sections: (1) The Hamster Wheel — 4-part anatomy in a visual grid; (2) for loop — array traversal and String char scanning; (3) while loop — String scanning, sentinel pattern, missing-update DWR; (4) do-while — input validation, AP exam scope note; (5) Enhanced for — can/cannot table, ArrayList traversal; (6) DWR + break — off-by-one, infinite loop, break in amber “emergency exit” box, continue; (7) Algorithms — accumulator, linear search, join, count chars in String, nested loops preview, uppercase filter; (8) Python — range(), no do-while, enumerate; (9) JavaScript — for...of, forEach.
Quick Reference: 15 rows covering all loop types, bounds patterns for arrays/strings/ArrayLists, accumulate, search, and nested loops. Queue updated: Loops removed; 2D Arrays moves to #6.
The algorithms section of Kata #5 includes a nested loops example (multiplication table) with the explicit note “Kata #6 will cover 2D Arrays in depth — this is the warmup.” This deliberate preview follows the same pattern as the Bridge kata (Kata #3) which previewed the Bridge concept before the dedicated kata existed. Bridging forward in each kata strengthens curriculum coherence.
Of course, with the inclusion of Kata #5 we need to update the summary in the chatlog.
An appropriately brief maintenance prompt. The “of course” opening signals that this is a routine step, not a design decision. Both relevant files are attached. The deduction comes from the missing specifics — which elements of the summary need updating, and to what depth.
✅ What worked well:
Key lesson: Even maintenance prompts benefit from a one-line specification. The ideal form for a chatlog update prompt: “Add Sessions 18–19 to the chatlog with CRAFT critiques and grades; update the back bar to Sessions 1–19, the hero subtitle, the overview summary paragraphs, and the What Exists inventory box.” Four targets, one sentence. The B acknowledges that the prompt accomplished its goal through established context rather than explicit specification.
A− • A • A • A • B+ • B+ • A− • A− • A • A−/A/B • A− • B+ • A− • A • A− • A • A • A • B
Trend: strong and improving. The two most reliable indicators of a high-grade prompt across the entire project: (1) reference files attached for context and format; (2) a role specification that names the AI’s relevant expertise. Session 18 achieved both — and produced the most complete kata build in the Dojo.
We have 5 Katas for our review. The 6th is devoted to 2D Arrays in Java. You are a web developer, co-developer at TNT and an experienced APCS-Java teacher as well as a grader for the APCS-A exam sponsored by the College Board. You have the previous Kata examples as well as a legacy APCS review that has a section on 2D Arrays. That handling is good, but you know it could be improved based on your knowledge of the AP exam and on common student misunderstandings. We’d like to build twoDArrayKata.html with its styling page twoDArrayKataStyles.css. I have a hero/card image of a Christmas ornament box that has ‘rows’ and ‘columns’ showing a fun mental image of 2D arrays that are seen in ‘everyday life.’ Let’s follow the example of the other Katas and show Python and JavaScript’s handling of the 2D array idea. Let’s also update our chatlog with this prompt, it’s critique and your analysis. Remember the summary will need to be updated too.
An excellent build prompt that continues the strong patterns established in Sessions 18. The AP grader role specification is the decisive element: it invites exam-calibrated content that generic role descriptions wouldn’t produce. The chatlog and summary update request is explicitly included.
✅ What worked well:
arr.length for both dimensions mistake, the arr[0].length empty-array trap. These are errors a practitioner sees; a generic “teacher” role might have produced more generic warnings.⚠️ What could be stronger:
twoDArrayKata.html (singular), but the existing navigation in loopsKata.html pointed to twoDArraysKata.html (plural). The AI created the file with the correct user-specified name and fixed the navigation link, but the discrepancy could have been flagged in the prompt: “Note: use the singular twoDArrayKata.html and check/fix any existing navigation references.”Key lesson: The AP grader role specification is a category unto itself. “Experienced teacher” produces good pedagogical content. “AP exam grader” produces content shaped by what actually appears on the exam and what errors students actually make under timed conditions. When accuracy under exam conditions matters, naming the grader role produces qualitatively different — and more valuable — content.
On the image: The “Christmas ornament box” is actually a rubber duck grid container — and that’s even better than ornaments. Rubber ducks are the official CS debugging mascot. A grid of rubber ducks wearing superhero costumes, each in its own [row][col] compartment, is a memorable 2D array metaphor that connects to both the Dojo’s whimsical tone and CS culture.
Built APCSDojo/twoDArrayKata.html (48KB) and APCSDojo/styles/twoDArrayKataStyles.css. Fixed loopsKata.html navigation link (was twoDArraysKata.html plural, corrected to twoDArrayKata.html singular). Home page Kata #6 card added (6 ✅ Available badges). Queue renumbered: 2D Arrays removed, OOP becomes #7, Inheritance #8, Conditionals #9, Recursion added at #10.
AP Grader additions beyond the legacy:
- Coordinate system trap: row is vertical (y-axis), col is horizontal (x-axis) — opposite of (x,y)
- DWR #1: Using
arr.lengthfor both bounds (the #1 exam error on 2D traversal) - DWR #5:
arr[0].lengthon empty array throws exception; guard witharr.length > 0 Arrays.deepToString()introduced as the correct print method- Python shared-row trap:
[[0]*4]*3creates shared references; use list comprehension - Column-major traversal pattern (outer = cols, inner = rows)
The DWR section of Kata #6 differs qualitatively from prior kata DWR sections. Rather than general gotchas, every warning maps to a specific error pattern observed in AP free-response grading: the arr.length-for-both-dimensions bug, the row/column swap, the enhanced-for modification trap, and the empty-array bounds crash. Future katas that have strong AP exam coverage (OOP, Inheritance, Recursion) should include the AP grader role explicitly to produce similarly calibrated content.
You are a web developer, APCS-Java teacher and AP grader for the college board but you are also a mathematician and respected software developer. You know that sometimes we need ‘ragged edge’ matrices for things like Pascal’s Triangle. I don’t believe that topic is on the AP exam, but we want our novices to be aware of the terminology and to see an example (like Pascal’s triangle) or the famous ‘see and say’ likeness series that starts with 1 and then goes 1 1 and then 2 1 and then 1 2 11 and so on, whose values could be stored in a ‘ragged edge’ matrix where the rows have unequal numbers of columns. Can you include this ‘Extra for Experts’ idea to our Kata page for 2D arrays? I’d suggest adding it after our JavaScript 2D Array synopsis. Let’s add this to our chatlog along with your analysis and critique. Of course, update the chatlog’s summary.
The richest role specification in the entire project — five distinct roles, each contributing something different to the output. The “Extra for Experts” label is a smart format directive that appropriately scopes the content without cluttering the exam-focused sections. The two specific examples (Pascal’s Triangle and Look-and-Say) give the AI two distinct demonstrations to build, ensuring breadth.
✅ What worked well:
⚠️ What could be stronger:
Key lesson: The five-role specification reveals a curriculum design principle: different roles produce different kinds of content. The AP grader produces DWR warnings. The mathematician produces Pascal’s Triangle. The software developer produces a clean, reusable algorithm. The teacher labels what’s on the exam and what’s not. Assembling the right role combination before a prompt is not overhead — it is curriculum quality control.
Added Section 09 (“Extra for Experts — Ragged Arrays”) to twoDArrayKata.html after the JavaScript section. Added .expert-box (gold-bordered callout) to twoDArrayKataStyles.css. Added “🌟 Ragged Arrays” nav pill. Added ragged array row to Quick Reference table.
Section content: (1) Ragged array declaration syntax (new int[n][] then per-row allocation); ragged traversal DWR (arr[r].length not arr[0].length); (2) Pascal’s Triangle — visual grid + buildPascal() recursive method; (3) Look-and-Say sequence — visual ragged grid showing unpredictable row lengths + nextLookAndSay() using ArrayList as dynamic builder (Kata #2 connection).
Hidden connection surfaced: The nextLookAndSay() method demonstrates the Bridge pattern from Kata #3 — ArrayList (Kata #2) builds a row of unknown length, then it’s converted to primitive int[] (Kata #1). The “Extra for Experts” section inadvertently became a showcase for the entire data-structures cluster working together.
Section 09 of Kata #6 establishes a pattern: each kata can include an optional “Extra for Experts” section for content that is real, relevant, and interesting but beyond the AP exam scope. This section is closed by default in the accordion (students who want exam prep only never see it), uses the gold-bordered .expert-box callout to signal its optional nature, and always includes an AP exam scope note. Future katas that have natural expert extensions (e.g., recursion, advanced OOP, generics) should follow this pattern.