This is an example output from the automated design review system described in The Ultimate Design Review: Orchestrating AI with Task-Based Workflows - Part 6 of 6.

This post shows how the AI transforms the comprehensive analysis into a structured, actionable backlog. The system automatically generates specific tasks with clear implementation steps, acceptance criteria, and testing requirements, turning qualitative feedback into a quantitative project plan.

Task Status Report: Design Review 2025-09-06 Action Items

Generated on: 2025-09-07

This is an example output from the automated design review system described in The Ultimate Design Review: Orchestrating AI with Task-Based Workflows - Part 6 of 6.

This post shows the comprehensive analysis that the AI generates when performing a full-scale design review of a codebase. The AI systematically analyzes each layer of the application, identifies architectural strengths and issues, and provides detailed findings that form the foundation for actionable improvement tasks.

Part 1 of 6: The AI-Assisted Development Workflow Series

This is the first installment in a six-part series exploring how AI is transforming modern development workflows. In this series, I’ll walk through my journey of using an AI-assisted development environment effectively, from basic infrastructure setup to advanced architectural enforcement and task orchestration.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

I’ve been spending a lot of time lately in the world of AI agents… wait, no, that’s not it. The Model Context Protocol. MCP. It’s a fancy way of saying “a way for AI models to talk to tools,” and it’s pretty powerful. But like any new toy, it comes with its own set of “some assembly required” headaches. Today, I want to talk about one of those: managing MCP servers, avoiding port conflicts, and generally keeping your digital workspace from turning into a tangled mess of wires.

Part 2 of 6: The AI-Assisted Development Workflow Series

This is the second installment in a six-part series exploring how AI is transforming modern development workflows. In this series, I’ll walk through my journey of building an AI-assisted development environment, from basic infrastructure setup to advanced architectural enforcement and task orchestration.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

If you’re a frontend developer, you know the love-hate relationship we have with ESLint. We love that it keeps our code clean and consistent. We hate spending hours wrestling with config files, trying to get plugins to play nicely with each other, especially in a modern TypeScript and Tailwind CSS v4 world.

Part 3 of 6: The AI-Assisted Development Workflow Series

This is the third installment in a six-part series exploring how AI is transforming modern development workflows. In this series, I’ll walk through my journey of building an AI-assisted development environment, from basic infrastructure setup to advanced architectural enforcement and task orchestration.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

We’ve all been there. You start a new project with Tailwind CSS, and everything is beautiful. The utility-first approach is fast, flexible, and keeps you right in your HTML. But as the project grows and the team expands, the CSS landscape can start to feel like the Wild West. Utility classes get sprinkled everywhere, components start to blur the lines between structure and style, and soon you’re overriding margins and fighting for specificity.

Part 4 of 6: The AI-Assisted Development Workflow Series

This is the fourth installment in a six-part series exploring how AI is transforming modern development workflows. In this series, I’ll walk through my journey of building an AI-assisted development environment, from basic infrastructure setup to advanced architectural enforcement and task orchestration.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

In my last post, I talked about how my AI pair programmer and I created a custom ESLint rule to enforce our new frontend architecture. It was a huge success. The linter, now armed with our specific rules, scanned the codebase and… gave us a giant list of things to fix.

Part 5 of 6: The AI-Assisted Development Workflow Series

This is the fifth installment in a six-part series exploring how AI is transforming modern development workflows. In this series, I’ll walk through my journey of building an AI-assisted development environment, from basic infrastructure setup to advanced architectural enforcement and task orchestration.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

In the previous posts, we’ve taught our AI assistant how to understand and enforce specific architectural rules. We’ve built a robust system for linting, testing, and managing complex tasks. But how do we ensure the AI behaves consistently and predictably over the long term? How do we give it a “personality” and a “memory” that aligns with our project’s philosophy?

Part 6 of 6: The AI-Assisted Development Workflow Series

This is the final installment in our six-part series on building an AI-assisted development workflow. We’ve set up our infrastructure, taught the AI our coding standards, and established a robust “memory bank” of project rules. Now, it’s time to put it all to the test with the ultimate challenge: a comprehensive, end-to-end design review of the entire codebase.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

The Challenge: From “Codebase” to “Action Plan”

Want to see what we’re building? I’ve created two example posts that show the actual output from this automated design review system:

This is an example output from the automated design review system described in The Ultimate Design Review: Orchestrating AI with Task-Based Workflows - Part 6 of 6.

This post shows how the AI transforms the comprehensive analysis into a structured, actionable backlog. The system automatically generates specific tasks with clear implementation steps, acceptance criteria, and testing requirements, turning qualitative feedback into a quantitative project plan.

Task Status Report: Design Review 2025-09-06 Action Items

Generated on: 2025-09-07

This is an example output from the automated design review system described in The Ultimate Design Review: Orchestrating AI with Task-Based Workflows - Part 6 of 6.

This post shows the comprehensive analysis that the AI generates when performing a full-scale design review of a codebase. The AI systematically analyzes each layer of the application, identifies architectural strengths and issues, and provides detailed findings that form the foundation for actionable improvement tasks.

Part 3 of 6: The AI-Assisted Development Workflow Series

This is the third installment in a six-part series exploring how AI is transforming modern development workflows. In this series, I’ll walk through my journey of building an AI-assisted development environment, from basic infrastructure setup to advanced architectural enforcement and task orchestration.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

We’ve all been there. You start a new project with Tailwind CSS, and everything is beautiful. The utility-first approach is fast, flexible, and keeps you right in your HTML. But as the project grows and the team expands, the CSS landscape can start to feel like the Wild West. Utility classes get sprinkled everywhere, components start to blur the lines between structure and style, and soon you’re overriding margins and fighting for specificity.

Part 5 of 6: The AI-Assisted Development Workflow Series

This is the fifth installment in a six-part series exploring how AI is transforming modern development workflows. In this series, I’ll walk through my journey of building an AI-assisted development environment, from basic infrastructure setup to advanced architectural enforcement and task orchestration.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

In the previous posts, we’ve taught our AI assistant how to understand and enforce specific architectural rules. We’ve built a robust system for linting, testing, and managing complex tasks. But how do we ensure the AI behaves consistently and predictably over the long term? How do we give it a “personality” and a “memory” that aligns with our project’s philosophy?

Part 6 of 6: The AI-Assisted Development Workflow Series

This is the final installment in our six-part series on building an AI-assisted development workflow. We’ve set up our infrastructure, taught the AI our coding standards, and established a robust “memory bank” of project rules. Now, it’s time to put it all to the test with the ultimate challenge: a comprehensive, end-to-end design review of the entire codebase.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

The Challenge: From “Codebase” to “Action Plan”

Want to see what we’re building? I’ve created two example posts that show the actual output from this automated design review system:

This is an example output from the automated design review system described in The Ultimate Design Review: Orchestrating AI with Task-Based Workflows - Part 6 of 6.

This post shows how the AI transforms the comprehensive analysis into a structured, actionable backlog. The system automatically generates specific tasks with clear implementation steps, acceptance criteria, and testing requirements, turning qualitative feedback into a quantitative project plan.

Task Status Report: Design Review 2025-09-06 Action Items

Generated on: 2025-09-07

This is an example output from the automated design review system described in The Ultimate Design Review: Orchestrating AI with Task-Based Workflows - Part 6 of 6.

This post shows the comprehensive analysis that the AI generates when performing a full-scale design review of a codebase. The AI systematically analyzes each layer of the application, identifies architectural strengths and issues, and provides detailed findings that form the foundation for actionable improvement tasks.

Part 6 of 6: The AI-Assisted Development Workflow Series

This is the final installment in our six-part series on building an AI-assisted development workflow. We’ve set up our infrastructure, taught the AI our coding standards, and established a robust “memory bank” of project rules. Now, it’s time to put it all to the test with the ultimate challenge: a comprehensive, end-to-end design review of the entire codebase.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

The Challenge: From “Codebase” to “Action Plan”

Want to see what we’re building? I’ve created two example posts that show the actual output from this automated design review system:

This is an example output from the automated design review system described in The Ultimate Design Review: Orchestrating AI with Task-Based Workflows - Part 6 of 6.

This post shows how the AI transforms the comprehensive analysis into a structured, actionable backlog. The system automatically generates specific tasks with clear implementation steps, acceptance criteria, and testing requirements, turning qualitative feedback into a quantitative project plan.

Task Status Report: Design Review 2025-09-06 Action Items

Generated on: 2025-09-07

This is an example output from the automated design review system described in The Ultimate Design Review: Orchestrating AI with Task-Based Workflows - Part 6 of 6.

This post shows the comprehensive analysis that the AI generates when performing a full-scale design review of a codebase. The AI systematically analyzes each layer of the application, identifies architectural strengths and issues, and provides detailed findings that form the foundation for actionable improvement tasks.

Part 5 of 6: The AI-Assisted Development Workflow Series

This is the fifth installment in a six-part series exploring how AI is transforming modern development workflows. In this series, I’ll walk through my journey of building an AI-assisted development environment, from basic infrastructure setup to advanced architectural enforcement and task orchestration.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

In the previous posts, we’ve taught our AI assistant how to understand and enforce specific architectural rules. We’ve built a robust system for linting, testing, and managing complex tasks. But how do we ensure the AI behaves consistently and predictably over the long term? How do we give it a “personality” and a “memory” that aligns with our project’s philosophy?

Part 6 of 6: The AI-Assisted Development Workflow Series

This is the final installment in our six-part series on building an AI-assisted development workflow. We’ve set up our infrastructure, taught the AI our coding standards, and established a robust “memory bank” of project rules. Now, it’s time to put it all to the test with the ultimate challenge: a comprehensive, end-to-end design review of the entire codebase.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

The Challenge: From “Codebase” to “Action Plan”

Want to see what we’re building? I’ve created two example posts that show the actual output from this automated design review system:

This is an example output from the automated design review system described in The Ultimate Design Review: Orchestrating AI with Task-Based Workflows - Part 6 of 6.

This post shows how the AI transforms the comprehensive analysis into a structured, actionable backlog. The system automatically generates specific tasks with clear implementation steps, acceptance criteria, and testing requirements, turning qualitative feedback into a quantitative project plan.

Task Status Report: Design Review 2025-09-06 Action Items

Generated on: 2025-09-07

This is an example output from the automated design review system described in The Ultimate Design Review: Orchestrating AI with Task-Based Workflows - Part 6 of 6.

This post shows the comprehensive analysis that the AI generates when performing a full-scale design review of a codebase. The AI systematically analyzes each layer of the application, identifies architectural strengths and issues, and provides detailed findings that form the foundation for actionable improvement tasks.

Part 6 of 6: The AI-Assisted Development Workflow Series

This is the final installment in our six-part series on building an AI-assisted development workflow. We’ve set up our infrastructure, taught the AI our coding standards, and established a robust “memory bank” of project rules. Now, it’s time to put it all to the test with the ultimate challenge: a comprehensive, end-to-end design review of the entire codebase.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

The Challenge: From “Codebase” to “Action Plan”

Want to see what we’re building? I’ve created two example posts that show the actual output from this automated design review system:

This is an example output from the automated design review system described in The Ultimate Design Review: Orchestrating AI with Task-Based Workflows - Part 6 of 6.

This post shows how the AI transforms the comprehensive analysis into a structured, actionable backlog. The system automatically generates specific tasks with clear implementation steps, acceptance criteria, and testing requirements, turning qualitative feedback into a quantitative project plan.

Task Status Report: Design Review 2025-09-06 Action Items

Generated on: 2025-09-07

This is an example output from the automated design review system described in The Ultimate Design Review: Orchestrating AI with Task-Based Workflows - Part 6 of 6.

This post shows the comprehensive analysis that the AI generates when performing a full-scale design review of a codebase. The AI systematically analyzes each layer of the application, identifies architectural strengths and issues, and provides detailed findings that form the foundation for actionable improvement tasks.

Part 1 of 6: The AI-Assisted Development Workflow Series

This is the first installment in a six-part series exploring how AI is transforming modern development workflows. In this series, I’ll walk through my journey of using an AI-assisted development environment effectively, from basic infrastructure setup to advanced architectural enforcement and task orchestration.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

I’ve been spending a lot of time lately in the world of AI agents… wait, no, that’s not it. The Model Context Protocol. MCP. It’s a fancy way of saying “a way for AI models to talk to tools,” and it’s pretty powerful. But like any new toy, it comes with its own set of “some assembly required” headaches. Today, I want to talk about one of those: managing MCP servers, avoiding port conflicts, and generally keeping your digital workspace from turning into a tangled mess of wires.

Part 2 of 6: The AI-Assisted Development Workflow Series

This is the second installment in a six-part series exploring how AI is transforming modern development workflows. In this series, I’ll walk through my journey of building an AI-assisted development environment, from basic infrastructure setup to advanced architectural enforcement and task orchestration.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

If you’re a frontend developer, you know the love-hate relationship we have with ESLint. We love that it keeps our code clean and consistent. We hate spending hours wrestling with config files, trying to get plugins to play nicely with each other, especially in a modern TypeScript and Tailwind CSS v4 world.

Part 3 of 6: The AI-Assisted Development Workflow Series

This is the third installment in a six-part series exploring how AI is transforming modern development workflows. In this series, I’ll walk through my journey of building an AI-assisted development environment, from basic infrastructure setup to advanced architectural enforcement and task orchestration.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

We’ve all been there. You start a new project with Tailwind CSS, and everything is beautiful. The utility-first approach is fast, flexible, and keeps you right in your HTML. But as the project grows and the team expands, the CSS landscape can start to feel like the Wild West. Utility classes get sprinkled everywhere, components start to blur the lines between structure and style, and soon you’re overriding margins and fighting for specificity.

Part 4 of 6: The AI-Assisted Development Workflow Series

This is the fourth installment in a six-part series exploring how AI is transforming modern development workflows. In this series, I’ll walk through my journey of building an AI-assisted development environment, from basic infrastructure setup to advanced architectural enforcement and task orchestration.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

In my last post, I talked about how my AI pair programmer and I created a custom ESLint rule to enforce our new frontend architecture. It was a huge success. The linter, now armed with our specific rules, scanned the codebase and… gave us a giant list of things to fix.

Part 5 of 6: The AI-Assisted Development Workflow Series

This is the fifth installment in a six-part series exploring how AI is transforming modern development workflows. In this series, I’ll walk through my journey of building an AI-assisted development environment, from basic infrastructure setup to advanced architectural enforcement and task orchestration.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

In the previous posts, we’ve taught our AI assistant how to understand and enforce specific architectural rules. We’ve built a robust system for linting, testing, and managing complex tasks. But how do we ensure the AI behaves consistently and predictably over the long term? How do we give it a “personality” and a “memory” that aligns with our project’s philosophy?

Part 6 of 6: The AI-Assisted Development Workflow Series

This is the final installment in our six-part series on building an AI-assisted development workflow. We’ve set up our infrastructure, taught the AI our coding standards, and established a robust “memory bank” of project rules. Now, it’s time to put it all to the test with the ultimate challenge: a comprehensive, end-to-end design review of the entire codebase.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

The Challenge: From “Codebase” to “Action Plan”

Want to see what we’re building? I’ve created two example posts that show the actual output from this automated design review system:

Let me start this with a confession:

I really wanted to like AppImages

The promise is compelling: universal Linux binaries that run everywhere without installation. Just download, chmod +x, and go. It’s the kind of elegant simplicity that makes you think “why didn’t we do this sooner?”

Then reality hits.

The Cursor Catalyst

This whole adventure started when I decided to try Cursor, the AI-powered code editor that’s my daily code editor. Unfortunately, it’s not updated frequently in AUR, so I decided to try the AppImage. When I tried to run it, I got the following error:

VS Code Profile Extension Manager (VPEM) is a powerful command-line tool designed to help you manage your Visual Studio Code extensions across different profiles. It allows you to dump, categorize, and apply extensions with ease, streamlining your VS Code setup process.

Status

This project has been developed strictly on Linux, though it should work everywhere. If you find an issue, please report it in the GitHub issue tracker.

Executables are built using pyinstaller and are available for Linux, Windows and MacOS. Again, if any issues are found, please report them in the GitHub issue tracker.

In starting this blog, I wanted to use AWS S3/CloudFront. I initially investigated SST (ion specifically). However, I kept running into issues with SST and NixOS, so I bailed on SST and moved directly to Pulumi. Pulumi is a Terraform competitor, and I have been curious to try it out.

They have a static site starter. This is actually a decent start, but I ran into a few problems deploying my new Eleventy Blog. The home page worked fine, but as you drive into sub-folders (like /blog/), I started getting 403 Forbidden errors.

Have you ever wished the Databricks widgets were a little more intelligent? When you change one, the others adjust?

That’s not too hard, but it’s a bit tricky. Here’s the secret: The widgets must be replaced as they change! For example:

Let’s say you have a date input, and whenever it changes, you want a second widget to change. That second widget needs to be suffixed with an increasing number as the contents change. Consider:

Recently, I ran into a case where I needed to check if 11 different fields were null. Yes, I could have used Copilot (or my preferred Codeium) to generate it for me, but I knew it had to be easier. There had to be an easier way…

Here’s the scenario:

• You have a list of conditions in a python list (in my case, I pasted it as separate lines and did a conditions = """condition 1\ncondition2\n...".split("\n")). Doesn’t matter how you specify your conditions, just that it’s a list somehow
• You have a way of associating this list with a set of Databricks columns

Here’s what I found:

Let me start this with a confession:

I don’t (technically) play Wordle

This is very important, as recently my wife came to me and proclaimed “I just got a “magnificent” in Wordle” (the blank look on my face definitely bumped up my heating bill for a few days). When I asked my daughter if she played it, she pointed me to Word Master and I was hooked.

Many discussions (with my daughter — my wife had no interest in our flagrant disrespect of Wordle) ensued about the best words to start. For the longest time, mine were train, speck, dough. You see, our philosophy was to bang out 2-3 words and get the letters, then stress over guessing the word after establishing a good set of letters (hopefully in the right position). I searched online for the best 3 words, but nobody seemed to follow this technique. Everybody writing about this only was interested in the best first word. So, off I went to figure it out.

Part 1 of 6: The AI-Assisted Development Workflow Series

This is the first installment in a six-part series exploring how AI is transforming modern development workflows. In this series, I’ll walk through my journey of using an AI-assisted development environment effectively, from basic infrastructure setup to advanced architectural enforcement and task orchestration.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

I’ve been spending a lot of time lately in the world of AI agents… wait, no, that’s not it. The Model Context Protocol. MCP. It’s a fancy way of saying “a way for AI models to talk to tools,” and it’s pretty powerful. But like any new toy, it comes with its own set of “some assembly required” headaches. Today, I want to talk about one of those: managing MCP servers, avoiding port conflicts, and generally keeping your digital workspace from turning into a tangled mess of wires.

Part 1 of 6: The AI-Assisted Development Workflow Series

This is the first installment in a six-part series exploring how AI is transforming modern development workflows. In this series, I’ll walk through my journey of using an AI-assisted development environment effectively, from basic infrastructure setup to advanced architectural enforcement and task orchestration.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

I’ve been spending a lot of time lately in the world of AI agents… wait, no, that’s not it. The Model Context Protocol. MCP. It’s a fancy way of saying “a way for AI models to talk to tools,” and it’s pretty powerful. But like any new toy, it comes with its own set of “some assembly required” headaches. Today, I want to talk about one of those: managing MCP servers, avoiding port conflicts, and generally keeping your digital workspace from turning into a tangled mess of wires.

Part 4 of 6: The AI-Assisted Development Workflow Series

This is the fourth installment in a six-part series exploring how AI is transforming modern development workflows. In this series, I’ll walk through my journey of building an AI-assisted development environment, from basic infrastructure setup to advanced architectural enforcement and task orchestration.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

In my last post, I talked about how my AI pair programmer and I created a custom ESLint rule to enforce our new frontend architecture. It was a huge success. The linter, now armed with our specific rules, scanned the codebase and… gave us a giant list of things to fix.

Part 1 of 6: The AI-Assisted Development Workflow Series

This is the first installment in a six-part series exploring how AI is transforming modern development workflows. In this series, I’ll walk through my journey of using an AI-assisted development environment effectively, from basic infrastructure setup to advanced architectural enforcement and task orchestration.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

I’ve been spending a lot of time lately in the world of AI agents… wait, no, that’s not it. The Model Context Protocol. MCP. It’s a fancy way of saying “a way for AI models to talk to tools,” and it’s pretty powerful. But like any new toy, it comes with its own set of “some assembly required” headaches. Today, I want to talk about one of those: managing MCP servers, avoiding port conflicts, and generally keeping your digital workspace from turning into a tangled mess of wires.

Part 2 of 6: The AI-Assisted Development Workflow Series

This is the second installment in a six-part series exploring how AI is transforming modern development workflows. In this series, I’ll walk through my journey of building an AI-assisted development environment, from basic infrastructure setup to advanced architectural enforcement and task orchestration.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

If you’re a frontend developer, you know the love-hate relationship we have with ESLint. We love that it keeps our code clean and consistent. We hate spending hours wrestling with config files, trying to get plugins to play nicely with each other, especially in a modern TypeScript and Tailwind CSS v4 world.

Part 3 of 6: The AI-Assisted Development Workflow Series

This is the third installment in a six-part series exploring how AI is transforming modern development workflows. In this series, I’ll walk through my journey of building an AI-assisted development environment, from basic infrastructure setup to advanced architectural enforcement and task orchestration.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

We’ve all been there. You start a new project with Tailwind CSS, and everything is beautiful. The utility-first approach is fast, flexible, and keeps you right in your HTML. But as the project grows and the team expands, the CSS landscape can start to feel like the Wild West. Utility classes get sprinkled everywhere, components start to blur the lines between structure and style, and soon you’re overriding margins and fighting for specificity.

Part 4 of 6: The AI-Assisted Development Workflow Series

This is the fourth installment in a six-part series exploring how AI is transforming modern development workflows. In this series, I’ll walk through my journey of building an AI-assisted development environment, from basic infrastructure setup to advanced architectural enforcement and task orchestration.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

In my last post, I talked about how my AI pair programmer and I created a custom ESLint rule to enforce our new frontend architecture. It was a huge success. The linter, now armed with our specific rules, scanned the codebase and… gave us a giant list of things to fix.

Part 2 of 6: The AI-Assisted Development Workflow Series

This is the second installment in a six-part series exploring how AI is transforming modern development workflows. In this series, I’ll walk through my journey of building an AI-assisted development environment, from basic infrastructure setup to advanced architectural enforcement and task orchestration.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

If you’re a frontend developer, you know the love-hate relationship we have with ESLint. We love that it keeps our code clean and consistent. We hate spending hours wrestling with config files, trying to get plugins to play nicely with each other, especially in a modern TypeScript and Tailwind CSS v4 world.

Part 3 of 6: The AI-Assisted Development Workflow Series

This is the third installment in a six-part series exploring how AI is transforming modern development workflows. In this series, I’ll walk through my journey of building an AI-assisted development environment, from basic infrastructure setup to advanced architectural enforcement and task orchestration.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

We’ve all been there. You start a new project with Tailwind CSS, and everything is beautiful. The utility-first approach is fast, flexible, and keeps you right in your HTML. But as the project grows and the team expands, the CSS landscape can start to feel like the Wild West. Utility classes get sprinkled everywhere, components start to blur the lines between structure and style, and soon you’re overriding margins and fighting for specificity.

Part 4 of 6: The AI-Assisted Development Workflow Series

This is the fourth installment in a six-part series exploring how AI is transforming modern development workflows. In this series, I’ll walk through my journey of building an AI-assisted development environment, from basic infrastructure setup to advanced architectural enforcement and task orchestration.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

In my last post, I talked about how my AI pair programmer and I created a custom ESLint rule to enforce our new frontend architecture. It was a huge success. The linter, now armed with our specific rules, scanned the codebase and… gave us a giant list of things to fix.

Part 2 of 6: The AI-Assisted Development Workflow Series

This is the second installment in a six-part series exploring how AI is transforming modern development workflows. In this series, I’ll walk through my journey of building an AI-assisted development environment, from basic infrastructure setup to advanced architectural enforcement and task orchestration.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

If you’re a frontend developer, you know the love-hate relationship we have with ESLint. We love that it keeps our code clean and consistent. We hate spending hours wrestling with config files, trying to get plugins to play nicely with each other, especially in a modern TypeScript and Tailwind CSS v4 world.

Part 3 of 6: The AI-Assisted Development Workflow Series

This is the third installment in a six-part series exploring how AI is transforming modern development workflows. In this series, I’ll walk through my journey of building an AI-assisted development environment, from basic infrastructure setup to advanced architectural enforcement and task orchestration.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

We’ve all been there. You start a new project with Tailwind CSS, and everything is beautiful. The utility-first approach is fast, flexible, and keeps you right in your HTML. But as the project grows and the team expands, the CSS landscape can start to feel like the Wild West. Utility classes get sprinkled everywhere, components start to blur the lines between structure and style, and soon you’re overriding margins and fighting for specificity.

Part 2 of 6: The AI-Assisted Development Workflow Series

This is the second installment in a six-part series exploring how AI is transforming modern development workflows. In this series, I’ll walk through my journey of building an AI-assisted development environment, from basic infrastructure setup to advanced architectural enforcement and task orchestration.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

If you’re a frontend developer, you know the love-hate relationship we have with ESLint. We love that it keeps our code clean and consistent. We hate spending hours wrestling with config files, trying to get plugins to play nicely with each other, especially in a modern TypeScript and Tailwind CSS v4 world.

Part 3 of 6: The AI-Assisted Development Workflow Series

This is the third installment in a six-part series exploring how AI is transforming modern development workflows. In this series, I’ll walk through my journey of building an AI-assisted development environment, from basic infrastructure setup to advanced architectural enforcement and task orchestration.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

We’ve all been there. You start a new project with Tailwind CSS, and everything is beautiful. The utility-first approach is fast, flexible, and keeps you right in your HTML. But as the project grows and the team expands, the CSS landscape can start to feel like the Wild West. Utility classes get sprinkled everywhere, components start to blur the lines between structure and style, and soon you’re overriding margins and fighting for specificity.

Part 4 of 6: The AI-Assisted Development Workflow Series

This is the fourth installment in a six-part series exploring how AI is transforming modern development workflows. In this series, I’ll walk through my journey of building an AI-assisted development environment, from basic infrastructure setup to advanced architectural enforcement and task orchestration.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

In my last post, I talked about how my AI pair programmer and I created a custom ESLint rule to enforce our new frontend architecture. It was a huge success. The linter, now armed with our specific rules, scanned the codebase and… gave us a giant list of things to fix.

Let me start this with a confession:

I don’t (technically) play Wordle

This is very important, as recently my wife came to me and proclaimed “I just got a “magnificent” in Wordle” (the blank look on my face definitely bumped up my heating bill for a few days). When I asked my daughter if she played it, she pointed me to Word Master and I was hooked.

Many discussions (with my daughter — my wife had no interest in our flagrant disrespect of Wordle) ensued about the best words to start. For the longest time, mine were train, speck, dough. You see, our philosophy was to bang out 2-3 words and get the letters, then stress over guessing the word after establishing a good set of letters (hopefully in the right position). I searched online for the best 3 words, but nobody seemed to follow this technique. Everybody writing about this only was interested in the best first word. So, off I went to figure it out.

Part 4 of 6: The AI-Assisted Development Workflow Series

This is the fourth installment in a six-part series exploring how AI is transforming modern development workflows. In this series, I’ll walk through my journey of building an AI-assisted development environment, from basic infrastructure setup to advanced architectural enforcement and task orchestration.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

In my last post, I talked about how my AI pair programmer and I created a custom ESLint rule to enforce our new frontend architecture. It was a huge success. The linter, now armed with our specific rules, scanned the codebase and… gave us a giant list of things to fix.

Part 5 of 6: The AI-Assisted Development Workflow Series

This is the fifth installment in a six-part series exploring how AI is transforming modern development workflows. In this series, I’ll walk through my journey of building an AI-assisted development environment, from basic infrastructure setup to advanced architectural enforcement and task orchestration.

Series Overview:

• Part 1: MCP Servers, Ports, and Sharing - Setting up the foundation
• Part 2: ESLint Configuration Refactoring - Cleaning up tooling with AI
• Part 3: Custom Architectural Rules - Teaching AI to enforce design patterns
• Part 4: Task Orchestration - Managing complex refactoring workflows
• Part 5: Project Rules for AI - Creating effective memory banks and guidelines
• Part 6: The Ultimate Design Review - Putting it all together

In the previous posts, we’ve taught our AI assistant how to understand and enforce specific architectural rules. We’ve built a robust system for linting, testing, and managing complex tasks. But how do we ensure the AI behaves consistently and predictably over the long term? How do we give it a “personality” and a “memory” that aligns with our project’s philosophy?

Let me start this with a confession:

I really wanted to like AppImages

The promise is compelling: universal Linux binaries that run everywhere without installation. Just download, chmod +x, and go. It’s the kind of elegant simplicity that makes you think “why didn’t we do this sooner?”

Then reality hits.

The Cursor Catalyst

This whole adventure started when I decided to try Cursor, the AI-powered code editor that’s my daily code editor. Unfortunately, it’s not updated frequently in AUR, so I decided to try the AppImage. When I tried to run it, I got the following error:

Let me start this with a confession:

I really wanted to like AppImages

The promise is compelling: universal Linux binaries that run everywhere without installation. Just download, chmod +x, and go. It’s the kind of elegant simplicity that makes you think “why didn’t we do this sooner?”

Then reality hits.

The Cursor Catalyst

This whole adventure started when I decided to try Cursor, the AI-powered code editor that’s my daily code editor. Unfortunately, it’s not updated frequently in AUR, so I decided to try the AppImage. When I tried to run it, I got the following error:

Let me start this with a confession:

I really wanted to like AppImages

The promise is compelling: universal Linux binaries that run everywhere without installation. Just download, chmod +x, and go. It’s the kind of elegant simplicity that makes you think “why didn’t we do this sooner?”

Then reality hits.

The Cursor Catalyst

This whole adventure started when I decided to try Cursor, the AI-powered code editor that’s my daily code editor. Unfortunately, it’s not updated frequently in AUR, so I decided to try the AppImage. When I tried to run it, I got the following error:

Let me start this with a confession:

I really wanted to like AppImages

The promise is compelling: universal Linux binaries that run everywhere without installation. Just download, chmod +x, and go. It’s the kind of elegant simplicity that makes you think “why didn’t we do this sooner?”

Then reality hits.

The Cursor Catalyst

This whole adventure started when I decided to try Cursor, the AI-powered code editor that’s my daily code editor. Unfortunately, it’s not updated frequently in AUR, so I decided to try the AppImage. When I tried to run it, I got the following error:

VS Code Profile Extension Manager (VPEM) is a powerful command-line tool designed to help you manage your Visual Studio Code extensions across different profiles. It allows you to dump, categorize, and apply extensions with ease, streamlining your VS Code setup process.

Status

This project has been developed strictly on Linux, though it should work everywhere. If you find an issue, please report it in the GitHub issue tracker.

Executables are built using pyinstaller and are available for Linux, Windows and MacOS. Again, if any issues are found, please report them in the GitHub issue tracker.

Photo by Kelly Sikkema on Unsplash

So, I recently had the opportunity to extensively dig into Gitlab’s CI/CD. We have a monorepo that I wanted to deploy automatically, and it took quite a bit of work to optimize it and work as I expected.

To set the stage, here’s our core .gitlab-ci.yml file (now):

image: node:18-alpine3.19

variables:
  AWS_REGION: us-east-1
  AWS_DEFAULT_REGION: us-east-1
  FF_USE_FASTZIP: "true"
  ARTIFACT_COMPRESSION_LEVEL: "fast"
  CACHE_COMPRESSION_LEVEL: "fast"

stages:
  - prepare
  - module-caches
  - layers
  - build
  - deploy

#******************************************************************

include:
  - local: ".gitlab/cache-ci.yml"
  - local: ".gitlab/rules-ci.yml"
  - local: ".gitlab/build-ci.yml"
  - local: ".gitlab/deploy-ci.yml"
  - local: "apps/landing/.gitlab-cache-ci.yml"
  - local: "apps/landing/.gitlab-ci.yml"
  - local: "apps/quickbooks-connector/.gitlab-ci.yml"
  - local: "apps/reviews/reviews-api/.gitlab-cache-ci.yml"
  - local: "apps/reviews/reviews-api/.gitlab-ci.yml"
  - local: "apps/reviews/reviews-ui/.gitlab-cache-ci.yml"
  - local: "apps/reviews/reviews-ui/.gitlab-ci.yml"
  - local: "apps/stocks/stocks-api/.gitlab-cache-ci.yml"
  - local: "apps/stocks/stocks-api/.gitlab-ci.yml"
  - local: "apps/stocks/stocks-ui/.gitlab-cache-ci.yml"
  - local: "apps/stocks/stocks-ui/.gitlab-ci.yml"
  - local: "apps/tnb/tnb-api/.gitlab-cache-ci.yml"
  - local: "apps/tnb/tnb-api/.gitlab-ci.yml"
  - local: "apps/tnb/tnb-ui/.gitlab-cache-ci.yml"
  - local: "apps/tnb/tnb-ui/.gitlab-ci.yml"
  - local: "packages/pinnacle-layer/.gitlab-cache-ci.yml"
  - local: "packages/pinnacle-layer/.gitlab-ci.yml"

# variables:
#   CI_DEBUG_TRACE: true

#******************************************************************

always:
  stage: prepare
  script:
    - env | sort

Here are some of the things that drove me crazy:

Photo by Kelly Sikkema on Unsplash

So, I recently had the opportunity to extensively dig into Gitlab’s CI/CD. We have a monorepo that I wanted to deploy automatically, and it took quite a bit of work to optimize it and work as I expected.

To set the stage, here’s our core .gitlab-ci.yml file (now):

image: node:18-alpine3.19

variables:
  AWS_REGION: us-east-1
  AWS_DEFAULT_REGION: us-east-1
  FF_USE_FASTZIP: "true"
  ARTIFACT_COMPRESSION_LEVEL: "fast"
  CACHE_COMPRESSION_LEVEL: "fast"

stages:
  - prepare
  - module-caches
  - layers
  - build
  - deploy

#******************************************************************

include:
  - local: ".gitlab/cache-ci.yml"
  - local: ".gitlab/rules-ci.yml"
  - local: ".gitlab/build-ci.yml"
  - local: ".gitlab/deploy-ci.yml"
  - local: "apps/landing/.gitlab-cache-ci.yml"
  - local: "apps/landing/.gitlab-ci.yml"
  - local: "apps/quickbooks-connector/.gitlab-ci.yml"
  - local: "apps/reviews/reviews-api/.gitlab-cache-ci.yml"
  - local: "apps/reviews/reviews-api/.gitlab-ci.yml"
  - local: "apps/reviews/reviews-ui/.gitlab-cache-ci.yml"
  - local: "apps/reviews/reviews-ui/.gitlab-ci.yml"
  - local: "apps/stocks/stocks-api/.gitlab-cache-ci.yml"
  - local: "apps/stocks/stocks-api/.gitlab-ci.yml"
  - local: "apps/stocks/stocks-ui/.gitlab-cache-ci.yml"
  - local: "apps/stocks/stocks-ui/.gitlab-ci.yml"
  - local: "apps/tnb/tnb-api/.gitlab-cache-ci.yml"
  - local: "apps/tnb/tnb-api/.gitlab-ci.yml"
  - local: "apps/tnb/tnb-ui/.gitlab-cache-ci.yml"
  - local: "apps/tnb/tnb-ui/.gitlab-ci.yml"
  - local: "packages/pinnacle-layer/.gitlab-cache-ci.yml"
  - local: "packages/pinnacle-layer/.gitlab-ci.yml"

# variables:
#   CI_DEBUG_TRACE: true

#******************************************************************

always:
  stage: prepare
  script:
    - env | sort

Here are some of the things that drove me crazy:

Photo by Kelly Sikkema on Unsplash

So, I recently had the opportunity to extensively dig into Gitlab’s CI/CD. We have a monorepo that I wanted to deploy automatically, and it took quite a bit of work to optimize it and work as I expected.

To set the stage, here’s our core .gitlab-ci.yml file (now):

image: node:18-alpine3.19

variables:
  AWS_REGION: us-east-1
  AWS_DEFAULT_REGION: us-east-1
  FF_USE_FASTZIP: "true"
  ARTIFACT_COMPRESSION_LEVEL: "fast"
  CACHE_COMPRESSION_LEVEL: "fast"

stages:
  - prepare
  - module-caches
  - layers
  - build
  - deploy

#******************************************************************

include:
  - local: ".gitlab/cache-ci.yml"
  - local: ".gitlab/rules-ci.yml"
  - local: ".gitlab/build-ci.yml"
  - local: ".gitlab/deploy-ci.yml"
  - local: "apps/landing/.gitlab-cache-ci.yml"
  - local: "apps/landing/.gitlab-ci.yml"
  - local: "apps/quickbooks-connector/.gitlab-ci.yml"
  - local: "apps/reviews/reviews-api/.gitlab-cache-ci.yml"
  - local: "apps/reviews/reviews-api/.gitlab-ci.yml"
  - local: "apps/reviews/reviews-ui/.gitlab-cache-ci.yml"
  - local: "apps/reviews/reviews-ui/.gitlab-ci.yml"
  - local: "apps/stocks/stocks-api/.gitlab-cache-ci.yml"
  - local: "apps/stocks/stocks-api/.gitlab-ci.yml"
  - local: "apps/stocks/stocks-ui/.gitlab-cache-ci.yml"
  - local: "apps/stocks/stocks-ui/.gitlab-ci.yml"
  - local: "apps/tnb/tnb-api/.gitlab-cache-ci.yml"
  - local: "apps/tnb/tnb-api/.gitlab-ci.yml"
  - local: "apps/tnb/tnb-ui/.gitlab-cache-ci.yml"
  - local: "apps/tnb/tnb-ui/.gitlab-ci.yml"
  - local: "packages/pinnacle-layer/.gitlab-cache-ci.yml"
  - local: "packages/pinnacle-layer/.gitlab-ci.yml"

# variables:
#   CI_DEBUG_TRACE: true

#******************************************************************

always:
  stage: prepare
  script:
    - env | sort

Here are some of the things that drove me crazy:

In starting this blog, I wanted to use AWS S3/CloudFront. I initially investigated SST (ion specifically). However, I kept running into issues with SST and NixOS, so I bailed on SST and moved directly to Pulumi. Pulumi is a Terraform competitor, and I have been curious to try it out.

They have a static site starter. This is actually a decent start, but I ran into a few problems deploying my new Eleventy Blog. The home page worked fine, but as you drive into sub-folders (like /blog/), I started getting 403 Forbidden errors.

Have you ever wished the Databricks widgets were a little more intelligent? When you change one, the others adjust?

That’s not too hard, but it’s a bit tricky. Here’s the secret: The widgets must be replaced as they change! For example:

Let’s say you have a date input, and whenever it changes, you want a second widget to change. That second widget needs to be suffixed with an increasing number as the contents change. Consider:

Recently, I ran into a case where I needed to check if 11 different fields were null. Yes, I could have used Copilot (or my preferred Codeium) to generate it for me, but I knew it had to be easier. There had to be an easier way…

Here’s the scenario:

• You have a list of conditions in a python list (in my case, I pasted it as separate lines and did a conditions = """condition 1\ncondition2\n...".split("\n")). Doesn’t matter how you specify your conditions, just that it’s a list somehow
• You have a way of associating this list with a set of Databricks columns

Here’s what I found:

In starting this blog, I wanted to use AWS S3/CloudFront. I initially investigated SST (ion specifically). However, I kept running into issues with SST and NixOS, so I bailed on SST and moved directly to Pulumi. Pulumi is a Terraform competitor, and I have been curious to try it out.

They have a static site starter. This is actually a decent start, but I ran into a few problems deploying my new Eleventy Blog. The home page worked fine, but as you drive into sub-folders (like /blog/), I started getting 403 Forbidden errors.

In starting this blog, I wanted to use AWS S3/CloudFront. I initially investigated SST (ion specifically). However, I kept running into issues with SST and NixOS, so I bailed on SST and moved directly to Pulumi. Pulumi is a Terraform competitor, and I have been curious to try it out.

They have a static site starter. This is actually a decent start, but I ran into a few problems deploying my new Eleventy Blog. The home page worked fine, but as you drive into sub-folders (like /blog/), I started getting 403 Forbidden errors.

In starting this blog, I wanted to use AWS S3/CloudFront. I initially investigated SST (ion specifically). However, I kept running into issues with SST and NixOS, so I bailed on SST and moved directly to Pulumi. Pulumi is a Terraform competitor, and I have been curious to try it out.

They have a static site starter. This is actually a decent start, but I ran into a few problems deploying my new Eleventy Blog. The home page worked fine, but as you drive into sub-folders (like /blog/), I started getting 403 Forbidden errors.

Have you ever wished the Databricks widgets were a little more intelligent? When you change one, the others adjust?

That’s not too hard, but it’s a bit tricky. Here’s the secret: The widgets must be replaced as they change! For example:

Let’s say you have a date input, and whenever it changes, you want a second widget to change. That second widget needs to be suffixed with an increasing number as the contents change. Consider:

Recently, I ran into a case where I needed to check if 11 different fields were null. Yes, I could have used Copilot (or my preferred Codeium) to generate it for me, but I knew it had to be easier. There had to be an easier way…

Here’s the scenario:

• You have a list of conditions in a python list (in my case, I pasted it as separate lines and did a conditions = """condition 1\ncondition2\n...".split("\n")). Doesn’t matter how you specify your conditions, just that it’s a list somehow
• You have a way of associating this list with a set of Databricks columns

Here’s what I found:

Have you ever wished the Databricks widgets were a little more intelligent? When you change one, the others adjust?

That’s not too hard, but it’s a bit tricky. Here’s the secret: The widgets must be replaced as they change! For example:

Let’s say you have a date input, and whenever it changes, you want a second widget to change. That second widget needs to be suffixed with an increasing number as the contents change. Consider:

Recently, I ran into a case where I needed to check if 11 different fields were null. Yes, I could have used Copilot (or my preferred Codeium) to generate it for me, but I knew it had to be easier. There had to be an easier way…

Here’s the scenario:

• You have a list of conditions in a python list (in my case, I pasted it as separate lines and did a conditions = """condition 1\ncondition2\n...".split("\n")). Doesn’t matter how you specify your conditions, just that it’s a list somehow
• You have a way of associating this list with a set of Databricks columns

Here’s what I found:

Let me start this with a confession:

I don’t (technically) play Wordle

This is very important, as recently my wife came to me and proclaimed “I just got a “magnificent” in Wordle” (the blank look on my face definitely bumped up my heating bill for a few days). When I asked my daughter if she played it, she pointed me to Word Master and I was hooked.

Many discussions (with my daughter — my wife had no interest in our flagrant disrespect of Wordle) ensued about the best words to start. For the longest time, mine were train, speck, dough. You see, our philosophy was to bang out 2-3 words and get the letters, then stress over guessing the word after establishing a good set of letters (hopefully in the right position). I searched online for the best 3 words, but nobody seemed to follow this technique. Everybody writing about this only was interested in the best first word. So, off I went to figure it out.