Don't Imitate Understand - #10

Hello!

In this tenth issue of the "Don't Imitate Understand" newsletter you'll get:

  • Course news then a discussion about maintaining skill in the age of AI, including an announcement of my first public free agent skills.
  • A bunch of interesting links!

Course News

  • The AI-assisted development course finished up a while back, which means my Modern JavaScript Frameworks course is getting all the attention. Look for updates soon.
  • In some personal related news, I've joined the Nielsen Norman Group as an instructional and experience designer. If you haven't heard of them, one of the founders Don Norman literally invented the term "user experience". It's an honor and a privilege to work with them, and you'll see some instructional work from me in the future regarding design, UX, and software dev in the age of AI.

Skills to Help Keep Your Skill

Usage of AI can cause skill atrophy. We know this, and if you've gone back to try coding by hand after using AI for a while you'll feel it.

However, this is not just a phenomenon but a real danger. You need to understand the code you're producing. This has security, maintenance, and accountability implications.

You also want your teammates to understand the code they're producing. Getting a massive AI-generated merge request that the coder doesn't understand is a nightmare for the dev doing the review.

To that end, I'm super excited to announce that I've released 3 new agent skills for you to use with your LLM that are designed to combat skill atrophy for yourself and your teammates.

Here's the short version: my new skills are do-i-understand, do-i-understand-the-ux, and de-div. These skills work with you to understand the implications of a commit or merge request, and de-div helps you be a semantic HTML author.

You can find all 3 agent skills on GitHub with instructions to install: https://github.com/AnthonyPAlicea/skills

If you appreciate these agent skills, giving the repo a star on GitHub is much appreciated to help the repo be found by others!

What do these skills do in detail? They are "don't imitate, understand" in skill form:

/do-i-understand

This is a reverse code review. The goal is to ensure that you, the developer, understand your AI-generated code well enough to be accountable for it, and it encourages you not to lose your skill in the age of LLM-generation.

Running /do-i-understand looks at the changes about to be pushed (or previous commits if you like), prioritizes changes to review with you, then probes your reasoning, the consequences, the assumptions you're making, and the ways the change could fail, trying to help you find the parts (if any) that you don't yet fully understand or haven't thought through yourself.

It provides an optional the report at the end to include in a merge request description for your reviewer or in a personal record for your own review.

When to use this skill

You might use this skill to:

  1. Maintain your own skill and understanding of your codebase.
  2. Make a safe space for junior engineers and require the usage of this skill as part of their PRs. Ask them not to submit the merge request until they are comfortable with their understanding, or to include the report in the PR description with "I don't know" as being a welcome answer that invites pair coding and mentorship.
  3. Open source maintainers may require a do-i-understand report in PRs as a light honor system requirement.

/do-i-understand-the-ux

This is an interview about the user experience you're about to ship. The goal is to make sure you understand what a user-facing change does to the person on the receiving end, well enough to be accountable for it, especially when an AI agent made the decisions.

Running /do-i-understand-the-ux on a PR, branch, commit, or diff translates the changed lines back into decisions about people, asks who the change is for and what they're trying to do, then interviews you about the changes where getting the consequence wrong would hurt users most. It probes for consequences you can trace and evidence you can name, whether that's research, data, a principle, convention, or a hunch.

It provides a report at the end to include in a merge request description for your reviewer, or keep it as a personal record of where your understanding of your users is thin.

When to use this skill

You might use this skill to:

  1. Be accountable for what AI-generated UI does to users before it ships, and keep your own UX judgment sharp while the tool writes the code.
  2. Give developers who ship user-facing changes without a designer on every PR a structured way to think through the experience, and let the reviewer see the open questions by including the report in the PR description.
  3. Catch the decisions that happened during generation and might mistakenly get accepted simply by looking polished.

/de-div

This skill helps you to be a skilled HTML author. The goal is to get the meaningless div and span soup out of your markup and replace it with semantic, accessible HTML, the kind that says what it is, not how it looks.

It works in two ways. In edit mode running /de-div de-divs markup you already have. In create mode it helps while generating something new and steers the markup toward the right elements.

In both modes it does the work where the choice is obvious, but when a choice is genuinely ambiguous it stops and thinks it through with you. It endeavors to keep your UI looking the same, accounting for the default styling that real elements bring.

Use the report at the end to see the types of semantic choices that were made and why. This helps you understand the choices well enough to be accountable for them and grow your semantic HTML authoring skill.

When to use this skill

You might use this skill to:

  1. Clean up div soup in an existing component, page, or whole codebase, without changing how it looks.
  2. Build new pages and components that are semantic and accessible from the start.
  3. Keep or improve your own knowledge (or that of junior team members) of semantic HTML. Use the LLM as a semantic thinking partner, read the report on its own decisions, and stay accountable for the markup you ship.

Installing these skills and running them as part of your process helps keep your skills sharp and keep yourself and your team accountable for the code you ship.

Don't let AI usage sap your core skills. I hope these skills help you, and, to help others find them, a GitHub star is appreciated!

LLMs aren't the end of coding, but a tool that those who maintain their skill will accomplish amazing work with.

Links

  • Beer CSS is the most semantic CSS framework I've ever seen.
  • I joined NN group, so I'll go ahead and recommend two of their courses to you: UX Maturity and A/B Testing. They're both outstanding, and extremely relevant to the AI age where you org UX needs to be mature and proper A/B testing helps you pick which AI-generated prototype you go with.
  • An excellent free PDF book to deepen your fundamental comp sci knowledge: Introduction to Compilers and Language Design

That's it for this tenth issue!

You received this because you either a) signed up for the newsletter directly on tonyalicea.dev or b) get emails from dontimitate.dev. If you enjoy my content, please let other people know about the newsletter! They can sign up here: https://tonyalicea.dev/newsletter/.

Happy coding!

Tony Alicea

Read the archive of this newsletter here.