Beyond the Prompt: My Road to Stage 4
- The Work Started Long Before the Certification: The rubric arrived on August 18 and the package was submitted 13 days later, because the team workflow and practices behind it had been building for years.
- I Didn’t Start With Skills. I Started With the Workflow: I thought I had to build every skill first, so I sketched the boxes, arrows, and contracts instead and kept each implementation swappable.
- Trust Is Built at the Handoffs: Four of thirteen early attempts worked, and the failures pointed at the handoffs, where trust gets tested and where the checks belong.
- A Feature Through the Harness: From Story to Screen: One real feature makes the workflow tangible, with three distinct measures and tests that check whose data appears.
- The System That Helped Me Learn What I’d Built: Activity logs and evidence records helped me understand the harness I had built, and opened the Stage 5 question of coordinating workflows.
My Road to Stage 3: Making the Learning Visible
- Making the Learning Visible: Why I would rather show the painful route than the finished result, starting with an assessment that exposed evaluation as my weakest link.
- Stories Long Before AI: How two decades of human stories and Given-When-Then shaped the way I approached evaluation-driven development.
- The Loop That Closed on 900 Cypress Tests: How a rubric loop made a 900-test Cypress-to-Playwright migration possible in about two hours of hands-on work.
- Testing the Wrong Unit: How evaluation revealed that what looked like one task was really three.
- When the Budget Ran Out: A hard usage limit, an ineffective PRD, and a package submitted in 40 minutes.
- The Cheapest Model in the Room: How switching to the cheapest model improved my skills and changed how I measured AI usage.
- Write the Skill That Builds Skills: How a one-off certification effort became a reusable story-to-prompt engine.
- Where the Critical Thinking Happens: Why evaluation criteria still need human thought, and where that thinking belongs.
A Decade at Improving
- 10 Years at Improving: The anniversary post that started it all, and the experiment that turned a Lunch & Learn Q&A into a full series.
- How a Lunch & Learn Became a Blog Series: How one hour of Improvers asking questions, plus a live workflow demo, produced fifteen posts instead of one.
- Do Blogging and Public Speaking Feed Each Other?: Writing slows your thinking down, talks force you to explain it, and the two keep looping back into each other.
- Why I Started Blogging and How I’ve Stayed Consistent for 21 Years: From translating FoxPro articles in 1999 to a self-printed magazine and a 21-year blog, consistency is about getting back up after the dips.
- The People and Programs That Kept Me Here: Come Together, the Involvement Program, ImprovU, PATH coaching, and the culture that makes sharing part of the job.
- The Biggest Surprise When I Joined: The Trust Thing: I knew the people before I joined; what surprised me was a company that trusted its consultants and wanted to change how IT is perceived.
- When the Room Goes Quiet: You prepare, you deliver, and sometimes it falls flat, so Stoicism, motivation, and the part you actually control.
- Ten Years of Slow Evolution: Culture did not change in dramatic events; Engage, trust pods, and Delivery Excellence each started small and settled in.
- Finding Your People in a Global Company: The icebreaker bot, Improving 100, and the in-person events that connect improvers across offices and countries.
- IT: Information Technology or Impact Technology?: We are drowning in information and starving for wisdom, and the shift starts with talking about impact instead of tools.
- Turn the Dials, Not Everything to Ten: There is no work-life balance, just life, so balance over a quarter, hobbies on the calendar, and the dials you choose to turn.
- Honest Feedback for a Place I Love: Onboarding overwhelm, drip-chart leveling questions, and a clear path to put internal apps behind SSO.
- Building a Sharing Culture Where It Doesn’t Exist: Leading by example: share the small things, plant the seed, and eventually the room shares back.
- How My Blogging System Grew Up (V1 to V2): The blogging system did not arrive finished; it grew from separate workflows into a project-driven system with a state engine.
- What a Blog Post Costs (and Why It’s Still Worth It): Tracking tokens, cost, views, and reactions, and why measuring the value of a post is hard but worth attempting.
- Writing Daily on the Cheapest AI Model: You do not need an expensive model to publish daily; refining the skills matters more than the price tag.
- The Feedback Loop: Turning Comments Into Content: Saving comments and reactions into Obsidian and mining them for the next post.
- Processes in Creativity: Why some people can adopt a process and others cannot, and why a messy process can still be the point.
- A Decade at Improving: Wrap-Up: Callbacks, payoffs, and what a decade of reflection and sharing made possible.
UX for Devs: Making Software Pretty Useful
- Why UX Is a Developer’s Job, Not a Designer’s Afterthought: Messy UX almost always lives next to messy code, because they are the same problem.
- Your Users Are Not Dumb — They’re Distracted, Stressed, and Short on Time: Stop assuming users share your context and design for people using your app while the world yells at them.
- Anticipate and Compensate: Surface the ‘Why’ Behind Disabled Buttons: Every boolean is a question the user might be asking, so answer it in the UI.
- Let Users Explore Safely: Stop Hiding Action Consequences: Do not bury the impact of an action six clicks deep; let users see what will happen before they commit.
- Navigate by Intent: Role-Based, Search-Driven UX for Complex Apps: In a system with hundreds of features, a menu is a trap, so let users type what they are trying to do.
- Speak Human: Natural Language, Task-Based UIs, and Better Labels: Cancel, Delete, and Save are technical verbs, and your users speak in business outcomes.
- Take What Users Have: Partial Input, Wizards, and Resumable Work: Users rarely have every answer when you want them, so build workflows that accept progress and resume later.
- From User Stories to Working Software: The Through-Line: The best UX comes from asking why one more time and writing tests that describe outcomes, not UI.
Documenting Sprints: From Chaos to Clarity
- Why My Sprints Used to Feel Like a Blur (Even Before AI): Two weeks of heads-down work and the details scatter, so the blur is a visibility problem, not a memory problem, and AI only sharpens it.
- A Personal Scrum for My Own Work: The transparency, inspection, and adaptation I preach to teams work at the scale of one, so my own work stays inspectable.
- My Sprint Note Template in Obsidian: One note per sprint, built during the sprint instead of reported at the end, with a few fields that make the work findable months later.
- Daily Notes and Breadcrumbs: How I Survive Interruptions: One daily note holds the day, links out to everything I touch, and leaves the breadcrumbs that cut recovery time after every interruption.
- Sprint Reviews and Retros That Don’t Rely on Memory: A review outline built from the sprint note turns a stressful demo into a confident story about what we did and why.
- From Sprint Notes to Career Capital: The same notes that keep sprints from blurring become the raw material for reviews, blog posts, talks, and a queryable history of my work.
Code Fluent: Thriving Through Language Shifts
- Am I Going to Lose My Job to AI?: The threat is older than AI, and it is aimed at people who only read and write code in one context.
- Tools Are Hammers and Screwdrivers: A tool is worth learning only if it solves a real problem for a real person.
- Stop Giving Users Data: Build for Insight: Users ask for a grid, but what they need is an answer to the decision they are trying to make.
- The Shifts That Actually Hurt: Programming Paradigms: Syntax is cheap, and the bruises come from changing how you think.
- From CRUD to Task-Based Thinking: Stop designing around tables and start designing around what the user is trying to do.
- Code Is for Humans (and AI): Write to Communicate: Clear intent makes every transition easier, whether the reader is a new teammate or an AI tool.
- Use the Tools, Don’t Let the Tools Use You: Owning a state-of-the-art IDE and using it like Notepad is not fluency; how you use the tool is.
- The Community Is the Curriculum: Learn in Public: Help the person five steps behind you, because teaching what you are learning is the fastest way to learn it.
- Strategic Growth: When to Deepen and When to Move On: Growth is not learning every new thing; it is making intentional bets that match your goals and context.
The Software Does Not Work – Rewrite It
- The Software Does Not Work – Should We Rewrite It?: Most rewrites fail before the first line of code because nobody asks the right questions.
- The Floppy Disk Handoff: When the Source Code Lies to You: A VB app on floppy disks whose source did not match the executable, and a manual that said “Check with Joe.”
- A 24/7 Operation: The Rewrite That Didn’t Need to Stop the World: A logistics rewrite that replaced the front end, the database, and the backend without ever shutting down.
- 500 Screens, One Idea: What Users Actually Need: Replacing 500 screens and cascading popups with one screen that users figured out without training.
- There Is No Domain (Yes, There Is): Pipeline Inspections and the Dynamic App: The FoxPro team said there was no domain, and one question found it hiding in plain sight.
- Why Calling FoxPro Forms from .NET Hurts: Interop is not magic, so keep business logic out of the UI and make the UI dumb and replaceable.
- When Silverlight Died, We Didn’t: The Thin UI Bet: Because the UI was a thin shell over an API, Microsoft killing Silverlight only cost us the thin layer.
- Excel in the Browser: A Rewrite That Never Launched: 80 filter dropdowns and a search screen that timed out before it ran, because UX is what makes a rewrite succeed or fail.
- A Year and a Half Without a Database: A working, clickable app with no persistent storage, because you figure out the right thing before deciding how to store it.
- What I Still Believe About Rewrites: After two decades, the language matters less than talking to the people who actually use the software.
Short-Term Goals, Real Results
- Stop Waiting for the 20-Year Vision: Why long-term vision paralyzes us, and how to start with the next 90 days.
- Pick the Right Goal-Setting Tool for the Season: SMART, Kaizen, WOOP, HARD, and LOCK are tools, not competing religions, so match the method to the moment.
- Tiny Experiments Beat Big Plans: “I will do X for Y time” lowers the stakes and replaces certainty with curiosity.
- Why You Procrastinate (Head, Heart, Hand): Procrastination as a signal: you do not know what to do, you do not care, or you lack the resources.
- Track Less, Learn More: A low-cost daily log and weekly review beats an expensive dashboard.
- Accountability Starts With You: Be your own first accountability partner, choose partners by role, and ask for critique, not criticism.
- Use Curiosity, Not Certainty, to Start: You do not need clarity to move; you need a low-stakes experiment.
- The Goal Is to Take Action Now: Environment design, motivation-proofing, and closing the gap between inspiration and action.
A Practical Guide to Journaling for Professional Growth
- Why Journal for Professional Growth: Knowledge workers own their learning, and journaling is the cheapest way to stop repeating discoveries and start compounding them.
- Overcome the Resistance to Journaling: Tool paralysis, privacy, and perfectionism are starting friction, not blockers.
- The Simplest Way to Start Journaling: A two-minute capture after focused work, getting the thoughts out of your head and optimizing later.
- The Need Problem Solution Journal Framework: A three-part structure for describing work so it stays useful later.
- The Six Core Reflection Questions: Six repeatable questions covering activity, problem, approach, value, resistance, and the reflect-relate-create loop.
- From Data to Impact: The Knowledge Cycle: Data, information, knowledge, insight, wisdom, and impact, plus the loop that feeds back into new data.
- Your First Week of Journaling: A day-by-day ramp from a career timeline to a full reflection framework.
- Tools, Setup, and Advanced Journaling Practices: Minimal, intermediate, and advanced setups, privacy boundaries, and insight-extraction prompts.
July 2026 AI Maturity Self-Assessment
- July 2026 AI Maturity Self-Assessment – Part 1: What a cleaner evidence set revealed about the way I use AI, including how I fix recurring failures at the system level.
- July 2026 AI Maturity Self-Assessment – Part 2: A closer look at AI governance, team practices, and stage mapping, beyond the assessment score.
The Recipe Pattern
- The Recipe Pattern Part 1: Why I Stopped Writing Validation Rules in the Frontend: Why duplicating validation rules across the backend and frontend leads to drift.
- The Recipe Pattern, Part 2: What the Frontend Does with the Rules: How the frontend consumes backend rule descriptions without owning business knowledge.
- The Recipe Pattern, Part 3: One Validator, Two Jobs: One validator both enforces rules and produces the recipe the frontend needs.
- The Recipe Pattern, Part 4: Testing Across the Boundary: How to test a pattern that spans the JSON contract, parser mapping, and validator output.