Back to Dojo Home S.P.A.R.K. Chat Log  •  11/11–12/2026  •  Sessions 1–21
S.P.A.R.K. with AI — Development Dialog

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

About This Chat Log — Read This First

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).

S.P.A.R.K. in This Project — The Big Picture

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.md is 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.
Session 1 — 2026-11-11 — 08:34
🎯
S — Set Goals (Session 1): Establish the Venue Concept Before writing a line of code, TTG asked for ideas, historical context, and a planning document. The goal was direction, not output. This is exactly what the S in S.P.A.R.K. demands.
The Prompt
TTG (TechToolsGuru)

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.

C.R.A.F.T. Prompt Critique — Session 1
A−

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:

✅Context (C) — Excellent. Four reference files attached (tntOverview.md, tntSnapshot, java_demos.html, three legacy resource pages). The AI received not just a description of TNT but actual documents to read. This is the highest form of context delivery.
✅Action (A) — Very clear. “Top 7 ideas” is a specific, countable deliverable. The request also names the first development task (arrays/ArrayList) and the second (Strings) — immediate forward planning baked into a concept prompt.
✅Planning ahead. Requesting 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.
✅Established precedent. Naming ToolTime and CrossTraining as analogs gave the AI a pattern to match, not a blank canvas to fill. “Like X and Y, but for Java review” is more precise than “something engaging.”
✅Discussion before development. The prompt asked for ideas, not a finished page. This is the most underused move in AI collaboration — asking “what should I build?” before “build it.”

⚠️ What could be stronger:

⚠️Role (R) — Implicit, not stated in the prompt. “You are a web developer…” was the first sentence — this is actually good! But it was part of the system context, not an explicit role instruction in the body of the prompt. Making the role explicit (“Respond as both a Java educator and a TNT-style web developer”) gives the AI two lenses to apply simultaneously.
⚠️Format (F) — Assumed, not specified. Seven ideas were requested, but the depth, length, and structure of each idea was left to the AI. A line like “For each idea, provide: a name, a one-sentence tagline, a movie clip suggestion, and a 2–3 sentence rationale” would have produced more consistent output.
⚠️Target (T) — Not stated. What makes a good theme? What’s the quality bar? A line like “Prioritize themes that work for 11th–12th graders, feel authentic to the TNT brand, and have a movie clip with strong pop-culture recognition” would have immediately narrowed the field.

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.

The Response
GitHub Copilot

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:

  1. 🚀 Mission Control — Apollo 13 (Failure is not an option). Unique tie to TTG’s rocket scientist background.
  2. ⚔️ The Arena — Gladiator (Maximus’ first entrance). Competitive APCS-A energy.
  3. 🥋 The Dojo — Karate Kid (Wax on, wax off). Patient mastery through repetition; “Compile. Debug. Repeat.”
  4. 🔨 The Forge — Thor / How to Train Your Dragon. Maker culture; raw materials become powerful tools.
  5. 🎮 Power-Up Station — Wreck-It Ralph (collecting the medal). Gamified; each concept is a power-up.
  6. 🔐 The Vault — Ocean’s Eleven (the full plan revealed). Strategic insiders; Java knowledge is the combination.
  7. 🏺 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.

Decision 1 — Markdown Tracking File Created

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.

💡
K — Know (Session 1): Three Prompting Principles
Session 1 Takeaways for Novice Prompters
  1. 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.
  2. 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.
  3. Request the planning document first. Asking for apcsPrepReviewIdeas.md in 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.
Session 2 — 2026-11-11 — 09:04
💬
P — Prompt (Session 2): Build the Movie Hook Page Theme selected: The Dojo. Now TTG moved from concept to first artifact — the movie clip hook page that will anchor the entire venue. This is the S.P.A.R.K. P phase: a focused, well-resourced prompt with concrete deliverables.
The Prompt
TTG (TechToolsGuru)

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.

C.R.A.F.T. Prompt Critique — Session 2
A

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:

✅Context (C) — Excellent. The sample movie clip page (agathaAllAlongMC.html) was attached as a formatting blueprint. The hero image was attached. The icon was attached. The YouTube embed code was provided inline. Four assets, all relevant, all immediately usable. This is model context delivery for a build prompt.
✅Action (A) — Precise. “Create waxOnWaxOffMC.html” names the exact file. “Model this new one after” (attached sample) specifies the approach. “Include a summary… and why this scene was so pivotal” names the content requirements explicitly.
✅Format (F) — Implicit but complete. The attached reference page provided a complete format template. The AI didn’t need to invent the structure — it had a working example to adapt. Using an existing page as a format guide is more powerful than describing a format in words.
✅Forward-looking link. “This movie clip page will eventually link to our APCSDojoHome.html” gave the AI the information it needed to create a placeholder link without being asked to build the destination. The result: a “coming soon” link already in place for Session 3.
✅Continuity requested. “Update our markdown file” ensured the planning document stayed current without a separate session. Building documentation update into every build prompt is a habit worth keeping.

⚠️ What could be stronger:

⚠️Content depth not specified for the connection section. The prompt said to explain “why novices need muscle memory in Java” but didn’t specify how. The AI chose three inline kata tables (the length family, element access, sorting). That was a good call, but specifying “give 3 concrete examples of Java distinctions that need to be reflexive” would have made that choice explicit rather than left to AI judgment.
⚠️Target (T) — Absent. No quality bar stated. What does “done” look like? “Students who read this page should come away convinced that Java muscle memory is real and that the Dojo is the place to build it” would have been a useful target sentence.

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.

The Response
GitHub Copilot

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 embed
  • images/Wax-On.jpg — hero image (Daniel and Miyagi waxing a car)
  • images/noun_judo_6346431_676767_@128.png — grid icon
  • movie_clips.html — new grid entry added at top
  • apcsPrepReviewIdeas.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.

Decision 2 — Dojo Icon & Grid Entry

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.

Decision 3 — Three Kata Preview Tables

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.

Session 3 — 2026-11-11 — 09:28
🏗️
P & A — Prompt & Analyze (Session 3): Home Page, Styles, and Chat Log The largest single-session build so far: four files requested in one prompt, with explicit requirements for content (CRAFT critique, SPARK analysis) embedded in the deliverables. The venue now has its structural scaffolding.
The Prompt
TTG (TechToolsGuru)

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.

C.R.A.F.T. Prompt Critique — Session 3
A

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:

✅Context (C) — Excellent. Four reference files attached: waxOnWaxOffMC.html (the page already built), crossTrainingHome.html, crossTrainingChatlog.html, toolTimeHome.html, toolTimeChatlog.html. The AI had live examples of both home pages and chatlogs in the TNT ecosystem. No format had to be invented; it was all there to read.
✅Action (A) — Highly specific. Four exact file names stated. The Arrays card, the hero image source, the chatlog content requirements — all named. “Same hero image as the movie clip” communicated a reuse decision in six words. “Summarize the md file” gave the chatlog its organizing content source.
✅Meta-requirements embedded. “Critique and grade my prompts according to our CRAFT mentality” and “show how we are using SPARK in our overall development” are meta-deliverables: requirements about the content of a deliverable, not just the deliverable itself. This is advanced prompting — asking the AI to make its reasoning visible inside the artifact it’s building.
✅Folder structure provided. “APCSDojo with sub folders for images, styles, scripts and sourceCode” gave the AI the deployment context before any file was written, preventing path errors.

⚠️ What could be stronger:

⚠️Home page section count not specified. “Begin with a card for the topic of Arrays” defines Kata #1, but the number of placeholder cards, upcoming queue items, and page sections was left to the AI. “Show three kata cards (one active, two placeholder) and a queue of four upcoming topics” would have made those choices explicit.
⚠️Chatlog session count not stated. “Summarize all the work we’ve done to date” is correct but open-ended. “Document all three sessions from today” would have confirmed the AI’s scope assumption rather than leaving it to infer from the markdown file.
⚠️Target (T) — Not stated. What does the home page succeed at doing? “A student who lands on this page should immediately understand what the Dojo is, want to try a kata, and feel the same ‘wax on, wax off’ energy as the movie clip page” would have been a useful target sentence.

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.

The Response
GitHub Copilot

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, footer
  • APCSDojo/styles/APCSDojoHomeStyles.css — all page-specific styles: hero, back bar, principle cards, kata entry cards, queue items, SPARK link cards
  • APCSDojo/APCSDojoChatlog.html — full development chat log with Sessions 1–3, CRAFT critiques, SPARK phase banners, and decision boxes
  • APCSDojo/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.

Decision 4 — APCSDojoHome Hero Reuses Wax-On.jpg

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.

Decision 5 — Kata Cards: One Active, Two Placeholder, Queue of Four

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.

💡
K — Know (Session 3): The Venue Has Its Scaffolding
What Exists Now — The Dojo Scaffolding After Three Sessions
  • 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.jpg and images/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.

🔧
R — Refine: What Comes Next The scaffolding is complete. The next phase is filling it — building the actual kata content pages that students will drill.
Planned Build Queue
  1. 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.
  2. 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.
  3. 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.
  4. Kata #3 — Strings (stringsKata.html) — builds on the legacy stringResource.html. The Pinocchio metaphor from the legacy page may be worth preserving.
  5. Kata #4+ — Loops, OOP, Inheritance, Conditionals, Recursion — queued; order TBD based on course calendar.
Session 4 — 2026-11-11 — 10:20
🤔
A — Analyze (Session 4): Blend vs. Separate — A Design Consultation Before building Kata #1, TTG paused to question a design decision made in Session 3. This is S.P.A.R.K. discipline at its best: the A phase deployed as a deliberate gate before the next P phase. The question: should primitive arrays, ArrayLists, and the Arrays class be on one kata page or separate pages? TTG’s original instinct said separate. Session 3 blended them. This session resolves the tension.
The Prompt
TTG (TechToolsGuru)

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.

C.R.A.F.T. Prompt Critique — Session 4
A

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:

✅Role (R) — Best in the series. “As an experienced computer science teacher and educational psychologist” invokes two specific disciplinary lenses simultaneously — the practitioner who has seen this confusion in real students, and the researcher who knows the cognitive science behind it. This is the most specific role specification in any of the four prompts and it produced a qualitatively different analysis as a result.
✅Context (C) — Excellent, again. Four reference files attached: the legacy arrayResource.html (original content), ThreeStoogesDriver.java (the bridge program), threeStoogesVibeCodeResults.html (the vibe-code progression showing the args → ArrayList arc), and the markdown planning doc. The AI could see both the content to be organized AND the real program that uses both concepts together.
✅Original design intent provided. TTG described his original plan in enough detail that the AI had a concrete alternative to compare against. “I had originally thought…” followed by a specific description of what each page would contain gave the AI the baseline for a genuine pros/cons analysis, not a strawman.
✅Guardrail: “Before we develop.” Third time this pattern has appeared. It is becoming a TTG prompting signature — a deliberate pause before action. This is exactly what the A in S.P.A.R.K. demands. Students reading this log should notice: the most experienced prompter in the room also uses the most explicit guardrails.
✅Continuity requested: “include this prompt and analysis in our chatlog.” Session 4 marks the fourth consecutive session in which TTG included a documentation request in the prompt. This is now a pattern, not an occasional reminder. The chatlog is treated as a first-class deliverable, not an afterthought.

⚠️ What could be stronger:

⚠️Format (F) — Not specified. “Pros and cons” is a structure, but the depth, length, and form of each point was left to the AI. “Give me a structured table of pros and cons, then a recommendation paragraph, then a proposed architecture” would have produced a more scannable output for a time-pressed teacher.
⚠️Target (T) — Implicit. The desired end state (“a final decision on page architecture before the first kata is built”) was implied but not stated. A line like “end with a clear recommendation I can say yes or no to” would have made the actionable output explicit.

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.

The Response — Design Analysis
GitHub Copilot

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.

Decision 6 — Separate: Three Deliverables Where One Was Planned

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.

Decision 7 — Home Page Kata Cards to Be Updated

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.

💡
K — Know (Session 4): When to Blend and When to Separate
Session 4 Takeaways for Novice Prompters & Curriculum Designers
  1. 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.
  2. 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.
  3. 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.
Session 5 — 2026-11-11 — 10:25
🍰
P — Prompt (Session 5): Confirm Architecture + Add the Bridge Kata A short, decisive follow-up prompt that confirms the Session 4 decision and extends it with a genuinely good idea: a third kata that shows how the first two interact. “Have our cake and eat it too” is an excellent framing — pedagogically, it’s the difference between knowing two kata and knowing when to apply them together.
The Prompt
TTG (TechToolsGuru)

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.’

C.R.A.F.T. Prompt Critique — Session 5
B+

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:

✅Decisive confirmation. “Let’s go with your recommendation” is unambiguous. The AI received a clear signal to implement the Session 4 decision rather than continue analyzing it. Many novice prompters get stuck in an analysis loop; TTG moved to action.
✅The cake metaphor is pedagogically astute. “Have our cake and eat it too” is not just a figure of speech here — it correctly identifies the genuine tension between separating concepts for depth and blending them for comparison. TTG perceived the tension from Session 4 and found the right architectural solution: a bridge kata that resolves it without compromising either goal.
✅Appropriate length for a follow-up. This prompt did not need three paragraphs. The context was fully established in Session 4; a short confirmation + extension is the correct form. Knowing when a prompt can be short is as important as knowing when it needs to be long.
✅ThreeStoogesDriver attached. Including the program that is literally the best possible bridge example — a single 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:

⚠️Action (A) — The bridge kata’s content was left entirely to the AI. What should the bridge kata cover? Conversion patterns? Side-by-side comparison tables? A decision guide? Real algorithm challenges using both? A line like “the bridge kata should cover conversion between the two, side-by-side syntax comparison, and ThreeStoogesDriver as the central example” would have produced a more precise content plan immediately.
⚠️No file name supplied. Sessions 2 and 3 both named their target files explicitly. This prompt did not name the bridge kata’s file (arraysBridgeKata.html). Small detail, but naming the file locks the decision and prevents any ambiguity about where the deliverable lives.
⚠️No chatlog update requested. Every previous session included an explicit request to update the chatlog or markdown. This session omitted it. The documentation update was done anyway, but explicitly requesting it maintains the habit and ensures it’s never accidentally dropped.

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.

The Response
GitHub Copilot

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 single main using String[] args (Kata #1) feeding into ArrayList<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).

Decision 8 — The Three-Kata Cluster Architecture is Final

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.

💡
K — Know (Session 5): The “Learn Separately, Apply Together” Pattern
Session 5 Takeaways for Curriculum Designers
  1. 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.
  2. 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.
  3. 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.
Session 6 — 2026-11-11 — 10:30
🏗️
P — Prompt (Session 6): Build Kata #1 — arraysKata.html The first kata page enters the world. The motel metaphor gets a full visual treatment: accordion sections, code blocks with ASCII art room diagrams, the DWR warning, the Arrays class as superpower unlock, and an exam-day Quick Reference table that the student should be able to reproduce from memory.
The Prompt
TTG (TechToolsGuru)

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.’

C.R.A.F.T. Prompt Critique — Session 6
B+

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:

✅Metaphor described with flavor. “No frills, set number of rooms, a bit shabby but lets us check people in” is vivid enough for the AI to build the metaphor section with authentic voice. The specific character details (“60s and 70s,” “shabby”) produce better content than “use a motel metaphor.”
✅Image handled correctly. “I have a picture I will supply” told the AI to build with a placeholder path (../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.
✅File names stated. arraysKata.html and arraysKataStyles.css named explicitly. No ambiguity.
✅Planning work paid off. Sessions 4 and 5 had already established the exact content scope: 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:

⚠️No section order specified. The sequence of sections (motel metaphor → declaration → args → traversal → algorithms → DWR → Arrays class) was inferred from Sessions 4–5 planning. Explicitly stating “sections in this order” would have locked the outline and prevented any reordering.
⚠️No chatlog update requested. Fourth session in a row where the documentation request was omitted. The update was done anyway, but the habit is slipping. For large build prompts especially, explicitly requesting “add Session X to the chatlog” prevents the documentation from falling behind the build.
⚠️Target (T) — not stated. What does a successful kata page accomplish? “A student who closes this page and writes the Quick Reference from memory should have everything they need for the AP exam” is a useful target sentence that would have confirmed the exam-day Quick Reference table was a required deliverable.

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.

The Response
GitHub Copilot

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:

  1. 🏨 The Motel Metaphor — conceptual framing with ASCII room diagram and off-by-one DWR
  2. 📝 Declaring & Building Arrays — three construction forms; default values table
  3. 🚗 String[] args — command-line motel visual; ThreeStoogesDriver guard pattern
  4. 🔄 Traversal — indexed for vs. enhanced for; when to use each
  5. 🧮 Common Algorithms — max/min, sum/average, count, fill, reverse
  6. ⚠️ DWR Warning — println(arr) memory address trap; char[] exception
  7. ⚡ 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.

Decision 9 — Motel Image: Placeholder Path Ready

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.

💡
K — Know (Session 6): The Planning Sessions Paid for the Build Session
What Exists Now After Session 6
  • Kata #1 — COMPLETE: APCSDojo/arraysKata.html + arraysKataStyles.css
  • Home page updated: Kata #1 card shows “✅ Available”
  • Pending: User to add images/javaMotel.jpg for the hero photograph
  • Next build: Kata #2 — ArrayList & the Collections Class (arrayListKata.html)
Session 7 — 2026-11-11 — 11:57
🥋
R — Refine (Session 7): Define the Kata Before the Student Clicks It A sharp UX observation: the word “kata” appears on every card, in the section header, and in the page titles — but never explained on the home page. A student who has never heard the word could mistake it for a Japanese app name or a typo. This session adds a whimsical working definition as a styled explainer callout, turning a potential confusion point into a teaching moment.
The Prompt
TTG (TechToolsGuru)

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?

C.R.A.F.T. Prompt Critique — Session 7
A−

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:

✅Target (T) — Best in the series. “When a user sees ‘arrayKata’ they know instantly what you’re talking about” is a measurable success criterion. The word “instantly” communicates that the definition must be short and in the right position, not buried three scrolls down. Specific targets produce specific, testable results.
✅Honest audience modeling. “New to me, likely new to my novices” is pedagogically astute — and rare. Many prompt writers assume their audience shares their context. TTG explicitly flagged the assumption gap, which prevented the AI from treating “kata” as familiar vocabulary and underselling the explanation.
✅Quality constraint: “whimsically.” This is a tone instruction, not just a format instruction. It shaped the voice of the explainer away from a dry dictionary entry toward the Dojo’s actual personality. “Whimsically” in a prompt costs one word and changes the entire character of the output.
✅Four reference files attached. Including the home page (the target file), the chatlog, the kata page (to understand what a kata actually contains), and the legacy arrayResource.html (original content) gave the AI all the context needed to write a definition that accurately describes the Dojo’s specific implementation of the kata concept.

⚠️ What could be stronger:

⚠️Placement not specified. “Frame it into the home page” left placement to the AI. The explainer ended up between the section heading and the kata cards — arguably the best location — but the prompter who says “add it between the kata section heading and the first kata card” never risks a misplaced definition.
⚠️No chatlog update requested. Fifth consecutive session without an explicit documentation request. The pattern of building in “add Session X to the chatlog” has drifted. The habit matters most precisely when the session produces a small-but-important change — because those are the changes most likely to be forgotten.

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.

The Response
GitHub Copilot

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.

Decision 10 — The Three-Mode Kata Protocol

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.

Session 8 — 2026-11-11 — 12:59
🌐
A — Analyze (Session 8): Where Does the Dojo Live in the TNT Ecosystem? After seven sessions building the venue, TTG pauses to ask where it belongs in the broader site. This is exactly the right instinct at exactly the right moment — before promoting it, understand what it deserves to be. The analysis revealed a genuine gap: not one of TNT’s ten Popular Destinations cards serves AP Java students. That gap is now closed.
The Prompt
TTG (TechToolsGuru)

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.

C.R.A.F.T. Prompt Critique — Session 8
A−

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:

✅New evidence provided. The JDoodle / web-native angle was not in any prior session. “Since this is a web-based venue, I’ve not always had a lot to offer [Java students], until now” is the pivotal argument for home page placement — and it’s real, specific, and persuasive. Surface new evidence when you have it; it changes the analysis.
✅Original plan stated. “Originally, I was going to feature this in resources” gave the AI a baseline to test against. The AI had two concrete options to compare, not an open-ended design question.
✅Format specified: chatlog. Fifth time TTG has specified a format in this series. The documentation habit is strong.
✅Target specified: “final determination.” The session should end with a decision and an implementation, not an open analysis. This is a prompt that knows its own end state.

⚠️ What could be stronger:

⚠️Binary framing missed a third option. “Home page + resources” vs. “resources only” — the prompt framed this as two choices but left the door open with “and also in resources.” The AI correctly identified both as simultaneously valid (not mutually exclusive), but a prompt that says “options include: home only, resources only, or both” would have made the third option explicit.
⚠️No gut direction shared. TTG was clearly leaning toward home page (“I’m now thinking it should be more prominent”). Sharing that lean — “I’m inclined toward home page; push back if you see problems” — makes the AI a better counterweight. An AI that knows you’re leaning one way can deliberately look for the opposing arguments. Without that signal, it has to guess your priors.

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.

The Analysis
GitHub Copilot

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.

Decision 11 — APCS Java Dojo Added to Popular Destinations (index.html)

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.

Decision 12 — APCS Java Dojo Added to Resources (TNT’s Own Resources)

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.

💡
K — Know (Session 8): New Evidence Changes the Case — Say It When You Have It
Session 8 Takeaways for Novice Prompters
  1. 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.
  2. 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.
  3. 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.
Session 9 — 2026-11-11 — 15:37
🏗️
P — Prompt (Session 9): Build Kata #2 — arrayListKata.html With Kata #1 complete and well-received (“I am very pleased with our arraysKata”), Kata #2 follows the same blueprint. The PODS Moving & Storage metaphor replaces the motel. The hero image is supplied. The legacy arrayListResource.html provides the content baseline. TTG explicitly notes the bridge boundary: save algorithms that work on both structures for Kata #3.
The Prompt
TTG (TechToolsGuru)

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.

C.R.A.F.T. Prompt Critique — Session 9
A

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:

✅Context (C) — Excellent. Six files attached: the existing kata page (format blueprint), the legacy arrayListResource.html (content baseline), the home page, the chatlog, the markdown file, and a hero image. The AI had everything needed to build a finished, deployable page without a single clarifying question.
✅Metaphor described with specificity. “Storage rooms that can be added, removed, and rearranged” followed by “Pod storage units that can be chained together” gave the AI a vivid, specific metaphor to build around. The PODS brand connection made the visual even stronger than a generic “dynamic storage” description.
✅Scope boundary explicitly stated. “Save the algorithms that work on both for Kata #3” is an excellent scope constraint. It prevented the AI from front-loading Kata #3 content into Kata #2, keeping each kata focused on its own concept area. This is curriculum design through prompting.
✅Gap acknowledgment and delegation. “I’m sure I’ve failed to include some important ones: add any that are must-know type routines” is a confident admission of limitation combined with a delegation instruction. This is mature prompting: know what you don’t know, name it, and ask the AI to fill the gap.
✅Chatlog update request restored. After being absent from Sessions 7, 8, and 9’s previous pattern, the explicit chatlog request returned: “Please add this development, prompt, critique, grade and analysis to our chatlog.” This is the most complete documentation request in the series — it names four specific deliverables (development, prompt, critique, grade, analysis).

⚠️ What could be stronger:

⚠️No section order specified. As with Session 6, the content outline was left to the AI. The sequence (PODS metaphor → declaration → generics → traversal → methods → algorithms → DWR → Collections) was inferred from the planning and the Kata #1 pattern. Explicitly stating a preferred order eliminates the ambiguity entirely.
⚠️Target (T) — not stated. No explicit success criterion. “After drilling this kata, a student should know 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.

The Response
GitHub Copilot

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:

  1. 🏗️ The PODS Metaphor — dynamic vs. fixed with ASCII pod lineups showing add/remove/shift
  2. 📝 Declaration, Construction & Initialization — import, three-step build, diamond syntax, println() works!
  3. 🧪 Generics & Wrapper Classes — why Integer not int, autoboxing, wrapper badge row
  4. 🔄 Traversal — indexed for (.get() and .size()), enhanced for, ConcurrentModificationException warning
  5. 🧰 Core Methods — full 12-method table (add, get, set, remove×2, size, contains, indexOf, lastIndexOf, clear, isEmpty)
  6. 🧮 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
  7. ⚠️ DWR Warnings — remove(int) vs remove(Object) Integer trap, ConcurrentModificationException, ArrayList<int> compile error
  8. ⚡ 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.

Decision 13 — Kata #2 Complete; The Bridge is Next

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.

Session 10 — 2026-11-11 — 16:08
🃏
R — Refine (Session 10): Dress Up the Kata Cards With all three kata pages built, attention turned to the home page cards that represent them. A three-part exchange: add hero background art and thematic icons (10a), a design consultation on whether the “Kata #N” labels compete with the images (10b), and a quick decision to remove them (10c). Small changes — meaningful visual improvement.
Prompt 10a — Card Beautification
TTG (TechToolsGuru)

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.

C.R.A.F.T. Critique — Prompt 10a
A−

✅ What worked well:

✅Format (F) — Gold standard. “We use this idea in CrossTrainingHome.html” named an existing, working example. Attaching that file gave the AI a live pattern to implement rather than a description to interpret. A reference file beats a format description every time.
✅Action (A) — Two requirements, both clear. Background art in the thumb area; icons next to the title in the body. These match CrossTraining’s .ct-entry-thumb-bg and .ct-entry-header pattern exactly.
⚠️No image paths specified. Which images for which cards was left to the AI. Specifying “Kata #1 → javaMotel.jpg, Kata #2 → pods-driveway-min.webp, Kata #3 → Wax-On.jpg” would have locked the visual decision. As it was, the AI chose appropriately but those choices should have been TTG’s.
Prompt 10b — Design Consultation
TTG (TechToolsGuru)

Do you think the labels of ‘Kata #x’ take away/detract from the pictures?

GitHub Copilot

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.

Prompt 10c — Decision
TTG (TechToolsGuru)

Yes, I agree. Change it. I don’t want the distractions.

C.R.A.F.T. Critique — Prompt 10b & 10c (Design Exchange)
A

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.

✅Asking for a design opinion is prompting maturity. The intermediate question “do these labels detract?” before acting on the change shows TTG treating the AI as a thinking partner, not a task executor. The AI’s answer included concrete reasoning (“CrossTraining uses empty thumbs”) that TTG could verify before committing.
✅The decision is clean and final. “I don’t want the distractions” communicates both the decision and the design principle behind it. Future similar decisions in this project (and others) can reference this: when visual elements compete, eliminate the one that serves the weaker purpose.
Decision 14 — Thumbnails Are Image-Only; Numbers Live in the Concept Label

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.

Session 11 — 2026-11-11 — 16:50
🎭
P — Prompt (Session 11): Build Kata #3 — The Bridge, Starring the Three Stooges The final kata in the data-structures cluster. The ThreeStoogesDriver vibe-code app — a program that uses both String[] args and ArrayList<String> in the same main — becomes the central teaching example. The Stooges image replaces the Wax-On.jpg placeholder. All three kata cards go live.
The Prompt
TTG (TechToolsGuru)

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.

C.R.A.F.T. Prompt Critique — Session 11
A−

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:

✅Pedagogical justification stated. “Since our stooges vibe code app uses command line prompts, primitive and ArrayLists” explains why this program is the right example, not just that it should be used. That reasoning shaped the entire section structure — the program is not just an example, it is the proof that the bridge concept matters.
✅Image source specified. “Use the stooges hero pic” named the asset and specified it for two locations (card thumbnail AND kata page hero). No ambiguity about which image or where.
✅Context (C) — Strong. Six files attached including 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.
✅The Bridge concept was already planned. Sessions 4 and 5 established what Kata #3 should cover: conversion patterns, side-by-side comparison, ThreeStoogesDriver. This prompt activated that plan. The planning investment paid off — a short prompt produced a complete page because the design was already decided.

⚠️ What could be stronger:

⚠️“Necessary information” is vague. What sections should the Bridge kata have? The AI inferred them from prior planning, but stating “sections should cover: the bridge concept, ThreeStoogesDriver walkthrough, array-to-ArrayList conversion, ArrayList-to-array conversion, side-by-side comparison, decision guide” would have made the scope explicit and verifiable.
⚠️No chatlog update requested. The documentation habit that returned strongly in Session 9 was absent again here. This is the kind of session — a major build completing a three-kata cluster — where the chatlog request matters most.

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.

The Response
GitHub Copilot

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.

Decision 15 — The Three-Kata Cluster Is Complete

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.

Session 12 — 2026-11-11 — 17:34
💬
K — Know & Share (Session 12): Catch Up the Chatlog Sessions 10 and 11 moved fast and the chatlog fell behind — a natural consequence of productive momentum. This session restores the documentation. The chatlog is the K in S.P.A.R.K.; falling behind it doesn’t erase the work, but it defers the teaching moment.
The Prompt
TTG (TechToolsGuru)

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.

C.R.A.F.T. Prompt Critique — Session 12
B+

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:

✅Recognized the gap and closed it. Documentation debt compounds quickly on active projects. By catching up at the end of a cluster rather than letting it drift further, TTG kept the chatlog current and useful. The best time to document is immediately after the work; the second-best time is now.
✅Context clause added. “As we made the Kata #3 about the bridge between primitive arrays and ArrayLists” names the work and the concept, which helps future readers calibrate what they’re about to read without having to scroll through three sessions first.

⚠️ What could be stronger:

⚠️“Last prompt” is slightly ambiguous. Multiple unlogged sessions preceded this one (card beautification at 16:08, label removal at 16:33, Kata #3 build at 16:50). “The last three sessions” or “Sessions 10, 11, and 12” would have been unambiguous. The AI resolved this by logging all unlogged sessions from Session 9 forward.
⚠️No depth specification. How detailed should the entries be? The AI defaulted to full CRAFT critiques, response summaries, and decision boxes — matching the established pattern. Explicitly saying “same depth as prior sessions” confirms this expectation rather than leaving it to inference.

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.

The Data Structures Cluster — Complete

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.

Session 13 — 2026-11-11 — 17:38
🐍
R — Refine (Session 13): Python Cross-Language Connection Added to Kata #3 Many TNT students arrive at Java via Python. This session added a cross-language bridge section to the Bridge kata — mapping Python list behavior to both Java structures, surfacing the sys.argv parallel, and naming the gotchas that trip up Python-to-Java travelers. The goal: make the same structures feel familiar, not foreign.
The Prompt
TTG (TechToolsGuru)

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!

C.R.A.F.T. Prompt Critique — Session 13
A−

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:

✅Target (T) — Best in class. “I want novices to make as many cross-language connections as they can” is the clearest pedagogical target in this project. It shaped not just the content but the tone: comparisons are framed as translations (“swap append() for add()”), not as new knowledge, which is exactly the right approach for students who already have Python fluency.
✅Two-part action, both clear. “How would you compare and contrast” (discussion) followed by “let’s add this as a footnote” (build) is a well-structured compound request. The discussion framing invited a genuine analysis rather than a lookup, and produced the three-column table comparison that is the section’s most useful artifact.
✅Context (C) — Complete. Five files attached including all three kata pages and the Bridge kata specifically. The AI could see exactly what content already existed and where the Python section fit without overlap.

⚠️ What could be stronger:

⚠️Format (F) — “Footnote” is ambiguous. The AI interpreted “footnote” as a full accordion section (Section 07). A literal footnote would have been a small <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.
⚠️Role (R) — Not stated. This prompt would benefit from “responding as a CS teacher who teaches both Python and Java.” That dual-language teaching lens would have produced a richer analysis — for example, the common misconception that Python lists “are like Java arrays” (they aren’t) is worth calling out explicitly as a teaching trap.

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.

The Response
GitHub Copilot

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-callout intro: 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.argv vs. String[] args code block — with the key gotcha: Python’s sys.argv[0] is the script name; Java’s args[0] is the first user argument. Same three-stooge program needs len(sys.argv) >= 4 in Python but args.length >= 3 in Java.
  • Bottom-line bullets: swap append() → add() and len() → 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 list is Python’s most elegant win.
Decision 16 — Cross-Language Sections Are a Kata Standard

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).

Session 14 — 2026-11-11 — 21:01
🪡
P — Prompt (Session 14): Build Kata #4 — Strings, Characters & the Character Class The richest content specification prompt in the series. TTG named specific topics, flagged a misconception to address, requested cross-language connections for two languages (not one), supplied a thematic hero image, attached the legacy resource, and stated the Pinocchio hook. The result: the most content-dense kata page in the Dojo.
The Prompt
TTG (TechToolsGuru)

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.

C.R.A.F.T. Prompt Critique — Session 14
A

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:

✅Context (C) — Complete. Seven files attached: existing kata pages (format blueprints), legacy stringResource.html (content baseline), the home page, the chatlog, the markdown, and a hero image. The AI had everything needed without a single clarifying question.
✅“not true?!” — best teaching-trap prompt in the series. Flagging the “Strings are arrays of chars” misconception with a question mark and exclamation invited a direct, authoritative answer. The result was Section 01’s “Are Java Strings arrays of characters?” with the loaf/slice analogy, a code block showing the compile error, and a DWR box. That misconception is now explicitly corrected on the page. This is teaching by prompting.
✅Two cross-language connections requested, not one. Prior sessions asked for Python. This session added JavaScript too — a natural extension that produced the most comprehensive cross-language section in the Dojo. The JS/Java s.length vs s.length() trap is now documented for the first time.
✅Specific topic list provided. “Strings, characters, the Character class, and even arrays” named four content areas. “Many examples should be provided” and the Pinocchio theme specified the voice. “Follow the examples of the other Katas” locked the format without requiring description.
✅File names stated. 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:

⚠️Role (R) — not stated. This prompt would benefit from “responding as a Java teacher who also knows Python and JavaScript.” The triple-language lens was implied by the content requirements but naming it would have produced an even sharper cross-language analysis.
⚠️No chatlog update requested. Fourteen sessions in, this habit has drifted. Session 15 caught it up, but Session 14 itself should have included “add this session to the chatlog.”

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.

The Response
GitHub Copilot

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:

  1. 🪡 The Pinocchio Metaphor — Strings as objects, immutability, and the definitive answer to “are Strings char arrays?” (No. Loaf ≠ slice.)
  2. 📝 Declaration — direct, constructor, empty vs. null, three ways char→String, from char array, concatenation and the accumulator pattern
  3. 🔡 chars & Character Class — single vs. double quotes, char arithmetic, full 9-method Character class table
  4. 🧰 Core Methods — 21-method table with Pinocchio examples throughout
  5. ⚠️ DWR Warnings — 5 traps: == vs .equals(), immutability discard, substring() exclusive end, null NPE, str[i] compile error
  6. 🧮 Algorithms — reverse, count chars, palindrome, count vowels, titleCase, remove spaces
  7. 🐍 Python Connection — 16-row comparison; 3 Java traps Python hides from you
  8. 🌐 JavaScript Connection — 17-row comparison; the s.length (no parens) vs s.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.

Decision 17 — JavaScript Added as a Standard Third Cross-Language Column

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).

Session 15 — 2026-11-11 — 21:19
📝
K — Know & Share (Session 15): Full Chatlog and Overview Update With four kata pages built in a single day, the chatlog had fallen two sessions behind and the overview summary still described only the first three sessions. This session restores documentation fidelity and updates all three header elements: back bar, hero subtitle, and About overview.
The Prompt
TTG (TechToolsGuru)

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.

C.R.A.F.T. Prompt Critique — Session 15
A−

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:

✅“Also include this prompt.” The reflexive documentation request returned. This is Session 15; the last time TTG explicitly requested chatlog inclusion in the prompt text was Session 9. The gap between Session 9 and Session 15 represents six sessions that required a catch-up. The lesson is now well-evidenced: build the documentation request into every session, not just the ones that feel significant.
✅Multi-part action clearly stated. “Update the summary/overview” + “add Kata #4 session” + “add this prompt” + “include critiques, grades, analysis” names four required components. Each one was delivered.
✅Context (C) — Complete. Four relevant files attached: the chatlog itself (target file), the markdown (session history reference), the home page (current state), and the Strings kata (Session 14 content to document).

⚠️ What could be stronger:

⚠️“Recent inclusion” is vague. Two sessions were unlogged (14 and 15). “Sessions 14 and 15 are unlogged” would have made the scope explicit and prevented any ambiguity about which sessions needed to be added.
⚠️Overview scope not specified. “Needs updating” left the AI to decide which parts of the overview to update. Specifying “update the session summary paragraphs, the hero subtitle, the back-bar span, and the SPARK R bullet” would have produced a more comprehensive update with zero guesswork.

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.

The Response
GitHub Copilot

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.

Decision 18 — Chatlog Update Is a Session-Closing Habit, Not an Afterthought

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.

🏆
K — Know (Session 15): The APCS Java Dojo After 15 Sessions
What Exists After 20 Sessions — The Full Dojo
  • ✅ 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
Session 16 — 2026-11-11 — 22:15
🔢
R — Refine (Session 16): String + Number Concatenation — Where Python Gets More Cumbersome A sharp-eyed refinement: the Python Connection section noted that both languages support + for concatenation but said nothing about the critical difference when one operand is a number, not a string. This session adds the missing contrast, the f-string solution, and a genuine design-philosophy analysis.
The Prompt
TTG (TechToolsGuru)

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.

C.R.A.F.T. Prompt Critique — Session 16
A

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:

✅“Is that your honest assessment too?” — sophisticated opinion-seeking. This phrase transforms the prompt from an instruction (“add this content”) into a conversation (“do you agree with my framing?”). The AI was invited to push back, qualify, or add nuance — and did. The result is a “Honest Assessment” callout that accurately reflects the trade-offs, not just the Python weakness.
✅Specific examples provided in the prompt. Both the Java version ("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.
✅“Also mention a string formatter.” Requesting the alternative (f-string / format()) alongside the limitation balances the Python section. A section that only shows Python’s weakness without its solution would be misleading. This prompt ensures fairness.
✅Chatlog inclusion requested. Session 16 is documented. The documentation habit returned — this was not a one-line refinement that gets forgotten.

⚠️ What could be stronger:

⚠️Placement not specified. Where in the Python section should this go? After the compare table? Before the traps callout? As a new sub-heading? The AI inserted it between the compare table and the traps callout — arguably the right position — but TTG could have specified this explicitly.

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.”

The Design Discussion — Honest Assessment
GitHub Copilot

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.”

Decision 19 — Cross-Language Sections Should Show Both Limitations and Strengths

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.

Session 17 — 2026-11-12 — 08:44
🗺️
A — Analyze (Session 17): Curriculum Sequencing — Pragmatic Ordering and the Next Kata Decision A multi-part design consultation. TTG explains the reasoning behind starting with Arrays (pragmatic: currently teaching it) and asks: should novices know this? And what comes next — 2D Arrays or Loops? This is curriculum design by prompting — using the AI as a thinking partner before committing to a build direction.
The Prompt
TTG (TechToolsGuru)

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.

C.R.A.F.T. Prompt Critique — Session 17
A

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:

✅Self-explaining reasoning. “The reason I started with arrays was pragmatic: this is a new facet of TNT training and we are currently learning about arrays.” Giving the AI the actual reasoning behind a past decision enables a richer analysis. The AI can evaluate the reasoning, not just the outcome, and can connect it to broader pedagogical principles.
✅Two distinct questions, both clearly framed. (1) Should novices see the pragmatic ordering rationale? (2) What are the pros/cons of 2D Arrays vs. Loops? Each is a separable question that could have been its own session. Asking both together is efficient and appropriate because the answers are related (the ordering justification affects the sequencing decision).
✅Deferred decision: discuss first, build later. “We can discuss this and then decide on our next steps” is the correct S.P.A.R.K. S-phase move. TTG is 17 sessions into this project and still using the guardrail. That discipline is worth noting explicitly.
✅Context (C) — Exceptional. Eight files attached including the legacy 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.
✅Documentation fully specified: “write these considerations up in our chatlog and markdown file, along with typical prompt critiques and grades.” All three deliverables named explicitly.

⚠️ What could be stronger:

⚠️Role (R) — not stated. This prompt would benefit from “respond as a CS curriculum designer and experienced Java teacher.” The dual-lens (designer + teacher) would have invited both the theoretical sequencing argument and the pragmatic classroom-reality argument simultaneously.
⚠️No gut direction shared. As in Session 8, TTG doesn’t share which way he’s leaning. Saying “I’m inclined toward Loops; push back if you see a reason to go with 2D Arrays first” would have invited a more targeted counterargument from the AI rather than a balanced presentation of both sides.

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.

The Analysis — Pragmatic Ordering and Next Kata
GitHub Copilot

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).

Decision 20 — Loops Before 2D Arrays; Pragmatic Ordering Acknowledged in Chatlog

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.

💡
K — Know (Session 17): Good Curriculum Meets Students Where They Are
A Note on the Dojo’s Sequence — Context for Future Readers

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.

Session 18 — 2026-11-12 — 09:12
🐹
P — Prompt (Session 18): Build Kata #5 — Loops & Iteration: The Hamster Wheel The strongest build prompt of the project. TTG names three explicit roles, supplies the hero image with an open critique invitation, specifies arrays and strings as primary teaching devices, names the infinite loop and break as required content, attaches the legacy loops review, and requests Python and JavaScript connections. Every C.R.A.F.T. element is present.
The Prompt
TTG (TechToolsGuru)

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.

C.R.A.F.T. Prompt Critique — Session 18
A

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:

✅Role (R) — Best in the project. “You are a web designer, experienced APCS teacher and grader and a co-designer at TNT” names three distinct roles simultaneously. Each role contributes something different: the web designer ensures the page follows TNT patterns; the APCS teacher/grader shapes the content and emphasis; the co-designer ensures the new kata fits the venue. This is the most complete role instruction in 18 sessions.
✅Image feedback invitation. “Feel free to suggest a better image/genre if you think of one!” invites a genuine aesthetic opinion, not just execution. This is rare and productive — it makes the AI a co-designer rather than a code generator. The hamster wheel was affirmed as the stronger choice over the alternative (runaway train) with specific reasoning.
✅Primary device specified. “Use arrays and strings as primary devices in building up the ideas of looping” is a pedagogical design directive that shaped every code example in the kata. Prior knowledge from Kata #1 and Kata #4 is explicitly leveraged — a continuity strategy that strengthens the Dojo as a cohesive curriculum.
✅Named content requirements. Infinite loop, break, runaway train analogy, common must-know algorithms. These are specific emphasis points, not just topic areas. Each one maps to a DWR box, a code example, or a named section.
✅Context (C) — Excellent. Eight files attached including the legacy apcsTestReview.html (loops section), all existing kata pages (format blueprints), the markdown file, and the hero image. Complete context delivery.

⚠️ What could be stronger:

⚠️Section structure not specified. The nine sections (wheel metaphor, for, while, do-while, enhanced for, DWR+break, algorithms, Python, JS) were inferred from the content requirements and the established kata pattern. Naming them explicitly would have confirmed TTG’s intent vs. the AI’s inference.
⚠️No chatlog update requested. The documentation habit has drifted again — Session 18 required a follow-up prompt (Session 19) to get documented. Five words at the end of every build prompt would have prevented this.

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.

The Response
GitHub Copilot

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.

Decision 21 — Nested Loops Introduced in Kata #5 as a Bridge to Kata #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.

Session 19 — 2026-11-12 — 09:40
📝
K — Know & Share (Session 19): Chatlog Summary Updated for Kata #5 A routine but important maintenance session: the overview hadn’t been updated since Session 15, leaving Sessions 16–18 unrepresented in the summary. Four elements updated: back bar, hero subtitle, overview paragraphs, and the “What Exists” inventory box.
The Prompt
TTG (TechToolsGuru)

Of course, with the inclusion of Kata #5 we need to update the summary in the chatlog.

C.R.A.F.T. Prompt Critique — Session 19
B

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:

✅Appropriate length. This prompt does not need three paragraphs. A brief, declarative sentence is the right form for a maintenance task with established context. Knowing when a prompt can be short is as valuable as knowing when it needs to be detailed.
⚠️No specific elements named. “Update the summary” leaves the AI to decide what “summary” means. “Update the back bar, hero subtitle, overview paragraphs, the What Exists inventory, and add Sessions 18–19 with critiques” would have produced a fully specified maintenance update with zero guesswork. The AI updated all four elements correctly, but on inference, not instruction.

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.

Grade Summary Across All 19 Sessions

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.

Session 20 — 2026-11-12 — 11:36
🗃️
P — Prompt (Session 20): Build Kata #6 — 2D Arrays: The Duck Grid Session 20 builds on Session 17’s architecture decision (Loops before 2D Arrays) and Session 18’s strong role-specification pattern. TTG continues the triple-role tradition, supplies a hero image (rubber duck grid container), and explicitly invokes the AP grader role to get exam-calibrated content. The summary update is included in the prompt.
The Prompt
TTG (TechToolsGuru)

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.

C.R.A.F.T. Prompt Critique — Session 20
A

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:

✅AP grader role specification. “A grader for the APCS-A exam sponsored by the College Board” is the most specific and powerful role instruction in the project. It produced the DWR section calibrated from real AP exam errors — the row/column swap, the 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.
✅“That handling is good, but it could be improved.” Explicitly asking the AI to extend and improve a known source (the legacy review) rather than just reproduce it is a strong prompting directive. It permits the AI to omit legacy content that’s already well-covered and add AP-exam-specific content that wasn’t.
✅Hero image with accurate description. “Rows and columns showing a fun mental image of 2D arrays in everyday life” identifies the pedagogical value of the image, not just its content. The image turned out to be a rubber duck grid container — even better than ornaments.
✅Summary update explicitly requested. “Remember the summary will need to be updated too” acknowledges the established chatlog workflow and specifies the often-missed overview update. This is the prompt demonstrating its own lesson from Session 15.
✅Context (C) — Complete. Nine files attached including the legacy review (source baseline), all existing kata pages (format blueprints), the markdown file, and the hero image.

⚠️ What could be stronger:

⚠️Section structure not specified. The eight sections (metaphor, declaration, access/dims, traversal, algorithms, DWR, Python, JS) were inferred. Naming the sections explicitly would have locked the outline.
⚠️File name discrepancy. The user specified 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.

The Response — AP Grader’s Perspective on the Image
GitHub Copilot

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.length for both bounds (the #1 exam error on 2D traversal)
  • DWR #5: arr[0].length on empty array throws exception; guard with arr.length > 0
  • Arrays.deepToString() introduced as the correct print method
  • Python shared-row trap: [[0]*4]*3 creates shared references; use list comprehension
  • Column-major traversal pattern (outer = cols, inner = rows)
Decision 22 — AP Grader Role Produces Exam-Calibrated DWR Content

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.

Session 21 — 2026-11-12 — 12:00
🌟
R — Refine (Session 21): Extra for Experts — Ragged Arrays, Pascal’s Triangle, Look-and-Say With Kata #6 complete, TTG extends it with an optional deep-dive section for students who want to understand 2D arrays at a mathematician’s level. The section adds two classic examples (Pascal’s Triangle and the Conway Look-and-Say sequence) and the critical ragged-array traversal correction that distinguishes a thorough understanding from exam-minimum knowledge.
The Prompt
TTG (TechToolsGuru)

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.

C.R.A.F.T. Prompt Critique — Session 21
A

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:

✅Five-role specification — richest in the project. “Web developer, APCS-Java teacher, AP grader, mathematician, and respected software developer” identifies five distinct lenses. The mathematician role is what produces Pascal’s Triangle and the Look-and-Say sequence as examples; the software developer role is what produces the clean algorithm (ArrayList as a dynamic builder before converting to int[]). No prior prompt used this many roles.
✅AP exam scope accurately stated. “I don’t believe that topic is on the AP exam” explicitly sets the depth: introduce, don’t drill. The resulting section is labeled “Extra for Experts,” kept voluntary (closed by default in the accordion), and paired with an AP exam scope note. Accurate self-assessment of content scope is a hallmark of a maturing curriculum designer.
✅Two specific examples named. Pascal’s Triangle (predictable, structured) and the Look-and-Say sequence (unpredictable, generative) together demonstrate the full range of ragged-array use cases: one where the size is known in advance, one where it must be computed dynamically. Naming both forced the section to cover both patterns.
✅Placement specified: after JavaScript section. This put the expert content at the end of the standard content, cleanly separated from exam-required material. Any student who opens the kata for AP review can stop at Section 08 and have everything they need.
✅Summary update requested. Documentation habit maintained for the second session in a row.

⚠️ What could be stronger:

⚠️Minor sequence description inaccuracy. The Look-and-Say sequence (also known as the Conway sequence) was described as “1 2 11” — likely meaning “1, 2, 1, 1” (four digits). The official sequence’s name and Wikipedia reference would add precision. This is a minor point; the description was clear enough to implement correctly.
⚠️No depth specification for each example. How much code? Just the data structure, or the generation algorithm too? The AI included both the structure (ragged array literal) and the algorithm (nextLookAndSay() using ArrayList) — a judgment call that worked out well but could have been specified: “show the data structure and an algorithm to generate the next term.”

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.

The Response — The Look-and-Say Kata Connection
GitHub Copilot

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.

Decision 23 — “Extra for Experts” as a Standard Kata Extension Pattern

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.