AI

Matt Pocock's Wayfinder Skill Notes

brooke — Mon, 02 Nov 2026 20:01:53 +0000

Matt Pocock's Wayfinder Skill Notes

Wayfinder Workflow

Use /wayfinder <prompt> to create a map with decision issues.
Wayfinder will ask you choose a destination: a buildable spec or an actual product.
After wayfinder has made the initial map, work through issues one at a time using /wayfinder <ticket number> until all decisions are made. Sometimes new issues will be created while working on other issues.
Wayfinder will utilize other skills, such as /grill-with-docs, /prototype, and /research.
- The map specifies when each of those other skills are to be used
The map also includes a list of 4 types of decision tickets:
- research
- prototype
- grilling
- task (things the agent can't quite do itself)
Once the map is made, then you can use /to-spec to turn the map into a spec.
Then use /to-tickets to create implementation tickets from the spec.
Use /implement to implement one ticket at at time
Use /implement-spec to have agents implement the whole spec AFK
Use /code-review afterward
Use /retro afterward to have the agent document what could have went better in the session.

Other mattpocock/skills that are helpful

/handoff: Compact the current conversation into a handoff document so another agent can continue the work.
/teach: Teach the user a new skill or concept over multiple sessions, using the current directory as a stateful teaching workspace.
/wait-what: Fire this the moment a message doesn't land.
/to-questionnaire: Turn a decision you can't answer alone into a Markdown questionnaire for the one person who can, filled in async, or together over a meeting. It grills you about the send (who it's for, what you need back), not the subject.

brooke Mon, 2 Nov 2026 - 12:01

Tags

Contrib Drupal Module Development

brooke — Mon, 02 Nov 2026 19:58:32 +0000

Contrib Drupal Module Development

One way to set up local Development for a contrib module using e0ipso's AI suite. See Agentic Coding Harness for Drupal

opt out of T3 telemetry by adding the following to ~/.ddev/.env
- T3CODE_TELEMETRY_ENABLED=false
Install https://github.com/e0ipso/self-review
Then:

BDEV_CURRENT_SITE="config_suite"
cd ~/Sites
git clone git@git.drupal.org:project/$BDEV_CURRENT_SITE.git
cd $BDEV_CURRENT_SITE
cp ~/projects/.gitignore-ddev .gitignore
ddev config --project-type=drupal11 --docroot=web
orb
ddev add-on get ddev/ddev-drupal-contrib
ddev add-on get hanoii/ddev-drupal-contrib-extras
ddev start
ddev poser

ddev symlink-project
ddev config --update
ddev restart
ddev drush si -y
ddev drush en $BDEV_CURRENT_SITE -y
open $(ddev drush uli)
ddev exec "cd web/core && yarn install"

# Temporary workaround on Mac because e0ipso's plugin only works for Linux for importing local OpenCode config
mkdir -p $HOME/Sites/$BDEV_CURRENT_SITE/.ddev/homeadditions/.local/share
ln -s $HOME/.local/share/opencode $HOME/Sites/$BDEV_CURRENT_SITE/.ddev/homeadditions/.local/share/opencode

ddev add-on get e0ipso/ddev-playwright-cli
ddev add-on get e0ipso/ddev-assistant-opencode
ddev add-on get e0ipso/ddev-assistant-t3
ddev restart

# Allows running playwright-cli from inside the container
#   without having to use the --config option
# Symlinks .claude playwright skills to .agents folder for other harnesses. 
ddev ssh

rm .playwright/cli.config.json
ln -s "$(pwd)/.ddev/playwright-cli/cli.config.json" .playwright/cli.config.json
mkdir -p .agents/skills
ln -s "$(pwd)/.claude/skills/playwright-cli" .agents/skills/playwright-cli
exit

npx kenkeep init --harnesses opencode
npx kenkeep doctor
npx kenkeep pack import e0ipso/kenkeep-pack-drupal
npx strikethroo init --harnesses opencode
npx skills add e0ipso/strikethroo

Strikethroo workflow: https://strikethroo.canpicasoft.com/workflow.html Kenkeep docs: https://kenkeep.canpicasoft.com/

ddev t3 start
npx strikethroo serve
/st-create-plan display a welcome message to new users
/st-refine-plan 1, see review.xml
/st-execute-blueprint 1
/st-code-review 1, line 95 in example.module has a typo: "piece" should be "peace"

brooke Mon, 2 Nov 2026 - 11:58

Tags

Drupal

DDEV

Notes for: Site Analysis and AI's Strengths and Limits, By David Hobbs

brooke — Mon, 02 Nov 2026 19:04:39 +0000

Notes for: Site Analysis and AI's Strengths and Limits, By David Hobbs

Just copying over some notes from a great video, in case it ever goes away:

Site Analysis and AI's Strengths and Limits

By David Hobbs

Progression of content analysis

#	Type	Example	Automation at scale?	Use Al?	Quantitative or Qualitative?
1	Traditional Automation	Crawl with [[Screaming Frog]]	Yes	No	Quantitative
2	Manual	Line-by-line qualitative audit	No	No	Qualitative
3	One-off Al	Ask ChatGPT a question about a site	No	Yes, one time	Qualitative
4	LLM → Deterministic	Have Claude write a script to run reading level analysis on every page	Partial	Yes, one time	Quantitative
5	Scaled Al	Pass thousands of pages to low power LLM to categorize	Yes	Yes, every page	Qualitative
Note: Al allows us to do some qualitative analysis that is NOT manual.

Advantages of particular types of content analysis


#	Type	Advantages
1	Traditional Automation	Easy to get basic information on many pages.
2	Manual	The approach everyone knows, and it feels like things are being done in a high quality manner (even before Al this was often the feeling).
3	One-off Al	Easy to get analysis that might be outside your expertise for a subset of pages.
4	LLM → Deterministic	Only use Al once, and then have all the advantages of traditional automation.
5	Scaled Al	Get qualitative information over a large swath of content (possibly impossible otherwise).

Disadvantages of the manual approach

Almost certainly leads to restricting the number of pages that are analyzed.
Very difficult to iterate or change course (such as if you decide to change the definition of audience)
Very difficult to merge analysis from multiple people.
Very difficult to be consistent.
Difficult to track over time.
Likely to encourage team to take action on content while analyzing it.

Disadvantages of one-off Al

Generally low transparency (How did it come up with the answer? Did it look at any pages? Did it consider your existing analysis?)
Related to the above, it can definitely hallucinate or over-extrapolate.
Generally requires powerful LLM
Can short circuit critical thinking of the analyst
NOT for pervasive analysis across a digital presence

Tip: If you do one-off chatbot analysis, explicitly ask how it came up with the answer and its sources. ie., "Explain to me in detail how you determined this. What sources did you use? What did you derive from each source? What confidence do you have in this answer?"

Disadvantages of LLM → Deterministic

Depending on skillset, can be difficult to evaluate whether the script is doing what you want it to do
Can be difficult to clearly specify the requirements
One-off efforts to write scripts can be difficult to reconcile together into a coherent whole

Keep in mind non-LLM automated analysis options

Near-text duplicate analysis
Graph database analysis (analysis of linkages between content / sections)
Scraping out information and component analysis
PDF analysis
Merge information (for instance from Google Analytics)
Reading level analysis
Charting
HTML structure analysis
Over-time analysis
Logo analysis
Formulas, maps, and rules
Technology analysis (such as with wappalyzer)

Tip: Consider converting problems to deterministic ones with AI

Disadvantage of Scaled Al

Difficult to develop on your own
Heavy processing is in the backend (not in chatbot)

TIp: Clearly differentiate between what's EASY to analyze and what's IMPORTANT to analyze.

Note: Far too often teams just revert to what's simple to analyze when that will not help them achieve their real business goals. For example, you can't analyze for consolidation if you only look at a small subset of pages because then you would be able to use a spreadsheet.

Summary

There is lots of automation that can be applied outside of LLMs.
For some questions, you really do need to look at the entire digital presence.
Al can help you accomplish qualitative assessments that required manual intervention before.
There are a variety of ways of using Al for site analysis.

Tips

Focus on refining the QUESTIONS you need answered.
If you do one-off chatbot analysis, explicitly ask how it came up with the answer in its sources.
Consider converting problems to deterministic ones with Al.
Clearly differentiate between what's EASY to analyze and what's IMPORTANT to analyze.

brooke Mon, 2 Nov 2026 - 11:04

Tags

Drupal

AI Ethics

brooke — Mon, 02 Nov 2026 18:58:09 +0000

AI Ethics

The Environment

From When the Clock Ticks Closer: AI, Ethics, and Drupal's Responsibility to the Public Good April 1, 2026

Data centers are multiplying across the globe drawing enormous quantities of power and water
from communities already under resource strain.
The raw materials required for AI hardware involve
- environmentally damaging extraction processes
- energy-intensive manufacturing
- growing mountains of electronic waste

"This is not an abstraction for the Drupal community. As an ecosystem that powers a substantial share of the world's web infrastructure - from small nonprofits to national governments - the collective energy footprint of Drupal-based sites and the hosting decisions behind them carries real weight. Organizations within the community have begun pushing for greener hosting choices, leaner architectures, and more deliberate thinking about when AI features add genuine value versus when they simply add compute."

brooke Mon, 2 Nov 2026 - 10:58

Tags

Drupal

Distillation of "LIVE: Uncle Bob on Software Fundamentals in the Age of AI"

brooke — Sun, 11 Oct 2026 16:20:13 +0000

Distillation of "LIVE: Uncle Bob on Software Fundamentals in the Age of AI"

This page has my notes about the youtube video that Matt Pocock produced called "LIVE: Uncle Bob on Software Fundamentals in the Age of AI". The video can be found here: https://www.youtube.com/watch?v=zcLPGC-tvgk

Main Takeaways

Bob describes how he has agents with specific jobs that handoff to each other in a workflow.
Bob uses mutation testing
- ie. change + to -, === to !=, false to true, etc, and the test suite should fail.
A main concept is: Agents fumble with long context, just like humans.
- We have limited short term memory.
- When we run out of short term memory, our work gets messy.
- Agents have longer and perfect short-term memory.
- Humans don't read all of what agents expect them to, and agents don't read all of what humans expect them to.
- 19:31 "when you focus the agents down to a single task, you're keeping the context window under control. The lost in the middle problem becomes much less of a problem."
- 29:34 "if you compartmentalize nicely works pretty well just like a human."
Bob uses an agile mindset when working with agents (instead of a waterfall-like approach with very rigid specs and planning beforehand).
- 36:49 "Wait a minute. All this heavy upfront planning makes a mess of everything cuz what comes out at the end doesn't look anything like the plan and never has."
Bob uses TDD when he codes but allows agents to write a function first and the test second.
- More details at 34:37 - 35:39

Bob's Agents

Specifier Agents: Gherkin Specifier Agent and QA Procedure Specifier Agent

These agents' job is to take a human-written document and turn it into another type of document.

Gherkin Specifier Agent: Creates a high level acceptance test using Gherkin
QA Procedure Agent: Creates "essentially a system test"
- Example of QA Procedure Agent from transcript:
  - 20:49 "I have them write it from a human's point of view:
    - You are a human.
    - You are operating this system at the UI.
    - You must prove that the system works."

Coder / Implementer

This agent's job is to

write unit tests
write the code
get the Gherkin working

Cleaner

This agent's job is to

Perform general code review (Change Risk Anti-Patterns)
then clean up the mess in the code that the coder/implementer inevitably left

Hardener

This agent's job is to

Run mutation testing

QA Agent

This agent's job is to

Turn "the written QA document into an executable script that manipulates the system and comes up with a deterministic result"

CRAP (Change Risk Anti-Patterns)

CRAP (Change Risk Anti-Patterns) analysis is a metric used to identify code that is highly complex and lacks adequate test coverage, making it risky and difficult to maintain.

43:44 Regarding CRAP, he has his agents write him his own crap tools for each language he writes in (Closure, Java, Go)
43:50 What I tell people is don't download those. I wrote them for me. What you should do is point your agents at them, have the agents look at them, and then build one for you.

brooke Sun, 11 Oct 2026 - 09:20

Tags