1 article tagged “pipeline” — software, engineering, and related writing by idmontie.

Pipeline blog posts - idmontie's Portfolio

"use strict";
const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0];
function _createMdxContent(props) {
  const _components = {
    a: "a",
    code: "code",
    h2: "h2",
    li: "li",
    p: "p",
    pre: "pre",
    ul: "ul",
    ...props.components
  };
  return _jsxs(_Fragment, {
    children: [_jsx(_components.p, {
      children: "Throughput is the name of the game now that the majority of engineers are using AI coding agents to write code. Delivering high quality product experiences that still provide accessible functionality is as important as ever."
    }), "\n", _jsx(_components.p, {
      children: "At Couchsurfing, I wanted to make sure that our web applications were as accessible as possible. As with my other articles touching on design systems and component architecture, my goal was to make it easy to write accessible applications, and make it extremely difficult – if not impossible – to write create bad experiences."
    }), "\n", _jsx(_components.p, {
      children: "This doesn’t just help those that need to use accessibility tools, but also uplifts the experience for everyone. Keyboard navigation works better, buttons are easier to click or press on any device, etc."
    }), "\n", _jsx(_components.h2, {
      children: "Make the Wrong Way the Hard Way"
    }), "\n", _jsx(_components.p, {
      children: "Let’s start at the bottom of the design hierarchy and recognize that if something is broken at the lowest level, there isn’t much hope of fixing it when delivering features or having a coding agent write code that utilizes that low level code."
    }), "\n", _jsxs(_components.p, {
      children: ["From ensuring that the low level tokens pass contrast rations, to ensuring that buttons always have an accessible label, our goal should be that if an engineer or coding agent uses a component from our component library, we provide an accessible experience. Writing good components is always a balancing act between creating a component that is too rigid, and one that is too flexible. The more flexible a component, the easier it is to use in the wrong way. I’ve ", _jsx(_components.a, {
        href: "/blog/post/2025-01-12-api-surfaces",
        children: "written about allowing too many boolean props"
      }), " in components before that can lead to a cartesian explosion in different component states, but also think about allowing too many pass-through props."]
    }), "\n", _jsx(_components.p, {
      children: "If, for example, we allow ariaLabel to be passed through to the button component, when do we expect engineers to pass in the prop? Leaving that question open means that we can end up in a case where we aren’t passing the prop when we need to, or we pass it in and conflict with the default accessible label of the button which would just be the content."
    }), "\n", _jsx(_components.p, {
      children: "When we split up components into their intended usage, it ends up being more clear when we should force an ariaLabel to be provided, and when we should just let the content act as the label."
    }), "\n", _jsx(_components.p, {
      children: "As a concrete example, I often have an IconButton split from the Primary|SecondaryButton family:"
    }), "\n", _jsx(_components.pre, {
      children: _jsx(_components.code, {
        className: "language-jsx",
        children: " export interface IconButton extends CoreButtonProps {\n   ariaLabel: string;\n   icon: ReactNode;\n }\n \n export interface PrimaryButton extends CoreButtonProps {\n   label: string;\n   prefixIcon?: ReactNode;\n }\n"
      })
    }), "\n", _jsxs(_components.p, {
      children: ["The rest of the props have been removed so we can focus on the label. I used ", _jsx(_components.code, {
        children: "ariaLabel"
      }), " as a required string, to indicate that we aren’t showing the label, but for accessibility purposes we require one. And on PrimaryButton, we don’t allow that prop at all, but we do require a string label. If we allowed arbitrary ReactNodes, we might not guarentee that it is text that can be detected as the label by the browser. This is also where I would enforce localization, but I have written ", _jsx(_components.a, {
        href: "/blog/post/2023-08-19-localization",
        children: "separate articles about that"
      }), "."]
    }), "\n", _jsx(_components.h2, {
      children: "Catching Issues"
    }), "\n", _jsx(_components.p, {
      children: "With our low level components set up for success, we beed a way to ensure we don’t introduce any issues – and we would like to catch any existing issues for any components that already exist. We’ll tackle this with a wide approach of tools:"
    }), "\n", _jsxs(_components.ul, {
      children: ["\n", _jsx(_components.li, {
        children: "Linting"
      }), "\n", _jsx(_components.li, {
        children: "Unit tests"
      }), "\n", _jsx(_components.li, {
        children: "Storybook"
      }), "\n", _jsx(_components.li, {
        children: "E2E"
      }), "\n"]
    }), "\n", _jsxs(_components.p, {
      children: ["At the linting level, I recommend looking at ", _jsx(_components.a, {
        href: "https://github.com/jsx-eslint/eslint-plugin-jsx-a11y",
        children: "eslint-plugin-jsx-a11y"
      }), " which catches a lot of bad patterns that seep into code. At Couchsurfing, we would also write out own custom rules on top of these any time we noticed a bad pattern being introduced."]
    }), "\n", _jsxs(_components.p, {
      children: ["For unit tests, we maintain a 80%+ code coverage metric which helps ensure we are writing tests for components. These gates fail the CI if they fall below the threshold. We would also use ", _jsx(_components.a, {
        href: "https://dev.to/ibn_abubakre/automated-testing-with-jest-axe-6fa",
        children: "jest-axe"
      }), " as a mechanism for catching a11y issues at the component level. The last tool we utilized as a jest plugin that turns all console warning and console errors into failing tests. If any unit test had an unexpected console warn or error, the entire test would fail."]
    }), "\n", _jsx(_components.p, {
      children: "At the storybook level, we would leverage the a11y plugin and periodically check if any components were breaking any issues. Typically these would be color contrast issues and we would work with designers to determine how best to fix them."
    }), "\n", _jsx(_components.p, {
      children: "For E2E testing, let’s shift our focus to Feature Delivery."
    }), "\n", _jsx(_components.h2, {
      children: "Feature Delivery"
    }), "\n", _jsx(_components.p, {
      children: "Delivering features typically has a different software lifecycle than working on a component library. Features are steadily shipped out, perhaps behind a feature flag, and combine a wide variety of design system level components and what I call “app level” components. These are reusable chunks of functionality that get shared across features in the application that might not belong to the design system. Maybe its a user card with functionality already wired up to load the user’s data. Or perhaps its an animated statistic that gets reused in a few spots in the application, but hasn’t been pulled into the design system."
    }), "\n", _jsx(_components.p, {
      children: "I typically treat these “app level” components similarly to that of a design system component. But in practice it is much harder to maintain the level of documentation, testing, and accessibility requirements at the “app level” since these are not all contained within a structured design system. These app level components might be scattered across different domains in the application, or maybe even different repos."
    }), "\n", _jsx(_components.p, {
      children: "To help ensure that accessibility is maintained across all these components and across the application as a whole, I like to add page level scanning as part of the continuous delivery pipeline. These type of tests might not run on every Pull Request, instead the might be a lagging indicator that runs nightly, and smoke checks a bunch of different pages in the application."
    }), "\n", _jsx(_components.p, {
      children: "One toolset I like to run nightly is Lighthouse CLI which checks a bunch of pages, and emits a reports that can be joined together. The output then goes to Slack or a ticket tracking system to be triaged and worked on by engineers. The nice thing about Lighthouse is that it already comes with a suite of accessibility checks that run against the actual running web application that customers would see."
    }), "\n", _jsx(_components.p, {
      children: "Even with jest unit tests and lint rules, there are some semantic accessibility checks that can still fail when components are composed together. For example, a link may have no descernable name when components are composed together and presented to the user. Or maybe the heading hierarchy of the page is out of order. In any case, the Lighthouse CLI audit will often catch these kind of issues."
    }), "\n", _jsx(_components.h2, {
      children: "Conclusion"
    }), "\n", _jsx(_components.p, {
      children: "Knowing all the different edge-cases that can cause accessibility issues is a challenge, but we can catch a lot of the issues early in the development cycle. This is especially true if we set engineering and coding agents up for success by building solid component libraries. The better these building blocks, the better the application will be overall. And with the majority of code being written by AI coding agents, having different types of checks at different points in the process will help catch issues that the agent may not have reasoned through."
    })]
  });
}
function MDXContent(props = {}) {
  const {wrapper: MDXLayout} = props.components || ({});
  return MDXLayout ? _jsx(MDXLayout, {
    ...props,
    children: _jsx(_createMdxContent, {
      ...props
    })
  }) : _createMdxContent(props);
}
return {
  default: MDXContent
};


<p>Throughput is the name of the game now that the majority of engineers are using AI coding agents to write code. Delivering high quality product experiences that still provide accessible functionality is as important as ever.</p>
<p>At Couchsurfing, I wanted to make sure that our web applications were as accessible as possible. As with my other articles touching on design systems and component architecture, my goal was to make it easy to write accessible applications, and make it extremely difficult – if not impossible – to write create bad experiences.</p>
<p>This doesn’t just help those that need to use accessibility tools, but also uplifts the experience for everyone. Keyboard navigation works better, buttons are easier to click or press on any device, etc.</p>
<h2>Make the Wrong Way the Hard Way</h2>
<p>Let’s start at the bottom of the design hierarchy and recognize that if something is broken at the lowest level, there isn’t much hope of fixing it when delivering features or having a coding agent write code that utilizes that low level code.</p>
<p>From ensuring that the low level tokens pass contrast rations, to ensuring that buttons always have an accessible label, our goal should be that if an engineer or coding agent uses a component from our component library, we provide an accessible experience. Writing good components is always a balancing act between creating a component that is too rigid, and one that is too flexible. The more flexible a component, the easier it is to use in the wrong way. I’ve <a href="/blog/post/2025-01-12-api-surfaces">written about allowing too many boolean props</a> in components before that can lead to a cartesian explosion in different component states, but also think about allowing too many pass-through props.</p>
<p>If, for example, we allow ariaLabel to be passed through to the button component, when do we expect engineers to pass in the prop? Leaving that question open means that we can end up in a case where we aren’t passing the prop when we need to, or we pass it in and conflict with the default accessible label of the button which would just be the content.</p>
<p>When we split up components into their intended usage, it ends up being more clear when we should force an ariaLabel to be provided, and when we should just let the content act as the label.</p>
<p>As a concrete example, I often have an IconButton split from the Primary|SecondaryButton family:</p>
<div class="overflow-auto rounded-2xl bg-[#0e005d6d] p-4 font-mono text-sm dark:bg-[#0e005d6d] dark:text-gray-100"><pre><code class="language-jsx"> export interface IconButton extends CoreButtonProps {
   ariaLabel: string;
   icon: ReactNode;
 }
 
 export interface PrimaryButton extends CoreButtonProps {
   label: string;
   prefixIcon?: ReactNode;
 }
</code></pre></div>
<p>The rest of the props have been removed so we can focus on the label. I used <code>ariaLabel</code> as a required string, to indicate that we aren’t showing the label, but for accessibility purposes we require one. And on PrimaryButton, we don’t allow that prop at all, but we do require a string label. If we allowed arbitrary ReactNodes, we might not guarentee that it is text that can be detected as the label by the browser. This is also where I would enforce localization, but I have written <a href="/blog/post/2023-08-19-localization">separate articles about that</a>.</p>
<h2>Catching Issues</h2>
<p>With our low level components set up for success, we beed a way to ensure we don’t introduce any issues – and we would like to catch any existing issues for any components that already exist. We’ll tackle this with a wide approach of tools:</p>
<ul>
<li>Linting</li>
<li>Unit tests</li>
<li>Storybook</li>
<li>E2E</li>
</ul>
<p>At the linting level, I recommend looking at <a href="https://github.com/jsx-eslint/eslint-plugin-jsx-a11y">eslint-plugin-jsx-a11y</a> which catches a lot of bad patterns that seep into code. At Couchsurfing, we would also write out own custom rules on top of these any time we noticed a bad pattern being introduced.</p>
<p>For unit tests, we maintain a 80%+ code coverage metric which helps ensure we are writing tests for components. These gates fail the CI if they fall below the threshold. We would also use <a href="https://dev.to/ibn_abubakre/automated-testing-with-jest-axe-6fa">jest-axe</a> as a mechanism for catching a11y issues at the component level. The last tool we utilized as a jest plugin that turns all console warning and console errors into failing tests. If any unit test had an unexpected console warn or error, the entire test would fail.</p>
<p>At the storybook level, we would leverage the a11y plugin and periodically check if any components were breaking any issues. Typically these would be color contrast issues and we would work with designers to determine how best to fix them.</p>
<p>For E2E testing, let’s shift our focus to Feature Delivery.</p>
<h2>Feature Delivery</h2>
<p>Delivering features typically has a different software lifecycle than working on a component library. Features are steadily shipped out, perhaps behind a feature flag, and combine a wide variety of design system level components and what I call “app level” components. These are reusable chunks of functionality that get shared across features in the application that might not belong to the design system. Maybe its a user card with functionality already wired up to load the user’s data. Or perhaps its an animated statistic that gets reused in a few spots in the application, but hasn’t been pulled into the design system.</p>
<p>I typically treat these “app level” components similarly to that of a design system component. But in practice it is much harder to maintain the level of documentation, testing, and accessibility requirements at the “app level” since these are not all contained within a structured design system. These app level components might be scattered across different domains in the application, or maybe even different repos.</p>
<p>To help ensure that accessibility is maintained across all these components and across the application as a whole, I like to add page level scanning as part of the continuous delivery pipeline. These type of tests might not run on every Pull Request, instead the might be a lagging indicator that runs nightly, and smoke checks a bunch of different pages in the application.</p>
<p>One toolset I like to run nightly is Lighthouse CLI which checks a bunch of pages, and emits a reports that can be joined together. The output then goes to Slack or a ticket tracking system to be triaged and worked on by engineers. The nice thing about Lighthouse is that it already comes with a suite of accessibility checks that run against the actual running web application that customers would see.</p>
<p>Even with jest unit tests and lint rules, there are some semantic accessibility checks that can still fail when components are composed together. For example, a link may have no descernable name when components are composed together and presented to the user. Or maybe the heading hierarchy of the page is out of order. In any case, the Lighthouse CLI audit will often catch these kind of issues.</p>
<h2>Conclusion</h2>
<p>Knowing all the different edge-cases that can cause accessibility issues is a challenge, but we can catch a lot of the issues early in the development cycle. This is especially true if we set engineering and coding agents up for success by building solid component libraries. The better these building blocks, the better the application will be overall. And with the majority of code being written by AI coding agents, having different types of checks at different points in the process will help catch issues that the agent may not have reasoned through.</p>


Throughput is the name of the game now that the majority of engineers are using AI coding agents to write code. Delivering high quality product experiences that still provide accessible functionality is as important as ever.

At Couchsurfing, I wanted to make sure that our web applications were as accessible as possible. As with my other articles touching on design systems and component architecture, my goal was to make it easy to write accessible applications, and make it extremely difficult – if not impossible – to write create bad experiences.

This doesn’t just help those that need to use accessibility tools, but also uplifts the experience for everyone. Keyboard navigation works better, buttons are easier to click or press on any device, etc.

## Make the Wrong Way the Hard Way

Let’s start at the bottom of the design hierarchy and recognize that if something is broken at the lowest level, there isn’t much hope of fixing it when delivering features or having a coding agent write code that utilizes that low level code.

From ensuring that the low level tokens pass contrast rations, to ensuring that buttons always have an accessible label, our goal should be that if an engineer or coding agent uses a component from our component library, we provide an accessible experience. Writing good components is always a balancing act between creating a component that is too rigid, and one that is too flexible. The more flexible a component, the easier it is to use in the wrong way. I’ve [written about allowing too many boolean props](/blog/post/2025-01-12-api-surfaces) in components before that can lead to a cartesian explosion in different component states, but also think about allowing too many pass-through props.

If, for example, we allow ariaLabel to be passed through to the button component, when do we expect engineers to pass in the prop? Leaving that question open means that we can end up in a case where we aren’t passing the prop when we need to, or we pass it in and conflict with the default accessible label of the button which would just be the content.

When we split up components into their intended usage, it ends up being more clear when we should force an ariaLabel to be provided, and when we should just let the content act as the label.

As a concrete example, I often have an IconButton split from the Primary|SecondaryButton family:

```jsx
 export interface IconButton extends CoreButtonProps {
   ariaLabel: string;
   icon: ReactNode;
 }
 
 export interface PrimaryButton extends CoreButtonProps {
   label: string;
   prefixIcon?: ReactNode;
 }
```

The rest of the props have been removed so we can focus on the label. I used `ariaLabel` as a required string, to indicate that we aren’t showing the label, but for accessibility purposes we require one. And on PrimaryButton, we don’t allow that prop at all, but we do require a string label. If we allowed arbitrary ReactNodes, we might not guarentee that it is text that can be detected as the label by the browser. This is also where I would enforce localization, but I have written [separate articles about that](/blog/post/2023-08-19-localization).


## Catching Issues

With our low level components set up for success, we beed a way to ensure we don’t introduce any issues – and we would like to catch any existing issues for any components that already exist. We’ll tackle this with a wide approach of tools:

- Linting
- Unit tests
- Storybook
- E2E

At the linting level, I recommend looking at [eslint-plugin-jsx-a11y](https://github.com/jsx-eslint/eslint-plugin-jsx-a11y) which catches a lot of bad patterns that seep into code. At Couchsurfing, we would also write out own custom rules on top of these any time we noticed a bad pattern being introduced.

For unit tests, we maintain a 80%+ code coverage metric which helps ensure we are writing tests for components. These gates fail the CI if they fall below the threshold. We would also use [jest-axe](https://dev.to/ibn_abubakre/automated-testing-with-jest-axe-6fa) as a mechanism for catching a11y issues at the component level. The last tool we utilized as a jest plugin that turns all console warning and console errors into failing tests. If any unit test had an unexpected console warn or error, the entire test would fail.

At the storybook level, we would leverage the a11y plugin and periodically check if any components were breaking any issues. Typically these would be color contrast issues and we would work with designers to determine how best to fix them.

For E2E testing, let’s shift our focus to Feature Delivery.

## Feature Delivery

Delivering features typically has a different software lifecycle than working on a component library. Features are steadily shipped out, perhaps behind a feature flag, and combine a wide variety of design system level components and what I call “app level” components. These are reusable chunks of functionality that get shared across features in the application that might not belong to the design system. Maybe its a user card with functionality already wired up to load the user’s data. Or perhaps its an animated statistic that gets reused in a few spots in the application, but hasn’t been pulled into the design system.

I typically treat these “app level” components similarly to that of a design system component. But in practice it is much harder to maintain the level of documentation, testing, and accessibility requirements at the “app level” since these are not all contained within a structured design system. These app level components might be scattered across different domains in the application, or maybe even different repos.

To help ensure that accessibility is maintained across all these components and across the application as a whole, I like to add page level scanning as part of the continuous delivery pipeline. These type of tests might not run on every Pull Request, instead the might be a lagging indicator that runs nightly, and smoke checks a bunch of different pages in the application.

One toolset I like to run nightly is Lighthouse CLI which checks a bunch of pages, and emits a reports that can be joined together. The output then goes to Slack or a ticket tracking system to be triaged and worked on by engineers. The nice thing about Lighthouse is that it already comes with a suite of accessibility checks that run against the actual running web application that customers would see.

Even with jest unit tests and lint rules, there are some semantic accessibility checks that can still fail when components are composed together. For example, a link may have no descernable name when components are composed together and presented to the user. Or maybe the heading hierarchy of the page is out of order. In any case, the Lighthouse CLI audit will often catch these kind of issues.

## Conclusion

Knowing all the different edge-cases that can cause accessibility issues is a challenge, but we can catch a lot of the issues early in the development cycle. This is especially true if we set engineering and coding agents up for success by building solid component libraries. The better these building blocks, the better the application will be overall. And with the majority of code being written by AI coding agents, having different types of checks at different points in the process will help catch issues that the agent may not have reasoned through.

pipeline posts

Building Accessibility into the Pipeline