How The Knot Accelerated Their AI-SDLC Transformation with DevClarity

The Knot Worldwide champions the power of celebration in more than ten countries around the world. Its global family of brands provide best-in-class products, services, and content to take celebration planning from inspiration to action. At the core of the business is their industry-leading global online wedding Vendor Marketplace, connecting couples with local wedding professionals and a comprehensive suite of personalized wedding websites, planning tools, invitations, and registry services that make wedding planning easier for couples around the globe. Each year, they connect more than 4 million users with around 900,000 global small businesses through their Vendor Marketplace.

The Knot wanted to move from individual experimentation with AI coding tools to consistent, team-level practice across a large engineering org and to make that shift stick at scale.

GitHub Copilot was already widely available, and engineers were experimenting on their own. What blocked broader progress was the absence of a shared mental model and repeatable patterns that teams could adopt and own. Gains stayed at the individual level instead of compounding across the org.

The work also needed to land across very different parts of the software development lifecycle and across different platforms:

• • A global platform spanning many repositories
• • A frontend estate mid-way through a design system migration
• • Areas for improvement in mobile test coverage
• • Day-to-day feature-development workflows
• • An internal autonomous coding effort that needed direction on architecture and rollout

DevClarity partnered with The Knot on a three-month AI coding enablement engagement. First, a baseline assessment mapped where teams were already strong and where the highest-leverage opportunities sat. Next, foundational training established fundamentals for the broader engineering group. Then, five focused workflows ran in parallel, each tackling a real, in-flight problem.

• • Baseline assessment. Working sessions covered tooling, requirements, coding measurement, and QA/testing, paired with a survey of more than 100 engineers across the org. This established a deeper understanding of the team's existing strengths and areas of opportunity.
• • Foundational training. Hands-on AI coding training covering planning, implementation, and testing phases. This gave the broader engineering group a shared foundation and the mental models needed to build and maintain AI-powered workflows in their own repositories.

The five focused workflows:

• • Scaling localization for a global platform. Building a repeatable workflow so any engineer could run a multi-repo localization migration without needing deep localization expertise. The result was a set of composable skills that handled setup, migration, and automated validation.
• • Easing a frontend design system migration. Pairing deterministic tool-specific execution (automated code rewrites) with AI-assisted component-by-component migration across a sprawling frontend estate. A shared knowledge file captured edge cases over time, so every future migration started smarter than the last.
• • Bootstrapping mobile test coverage. Tackling a gap on iOS by building AI-assisted skills that draft most of a working test flow on the first pass and audit the app for missing accessibility identifiers.
• • Packaging the daily feature-development cycle. Turning the ticket-to-code workflow into a composable set of skills that pull context from project management and design tools, generate plans, and carry work across UI and API repos with human-in-the-loop checkpoints.
• • Advising on the org's autonomous coding work. Guiding the team's internal autonomous coding effort, including centralization architecture, sandboxing, model evaluation, and a rollout path from single-squad pilot to broader deployment.

Across every effort, the same pattern showed up. Skills became the team-level unit of reuse. Tool use, Model Context Protocol (MCP) servers, and context files came along with them. The work was done in real production repos with the engineers who would own it going forward.

Quantitative shifts measured across beginning and ending surveys:

• • AI coding time grew from 47% to 62%.
• • Confidence in AI output improved, with developers reporting stronger trust in AI-generated code after the engagement.
• • Process integration shifted from ad-hoc experimentation to structured, repeatable use, with teams following planning-first workflows and human-in-the-loop checkpoints.

The team now reported that when using AI coding tools, they saw:

• • 70% velocity increase on repetitive tasks like boilerplate code generation and simple tests.
• • 42% increase in overall weekly output measured across features shipped, tests written, and code reviewed.

Qualitative shifts in how teams work:

• • Skills became the team-level unit of reuse. Developers called skills the engagement's highest-impact takeaway, and prompts and skills are crossing team boundaries. Developers pair skills with tool use, pulling context from the right MCP server for each job.
• • Reusable workflows for internal scaling projects. Two of the workflows shared the same shape of problem: an internal initiative scaling across many repositories with otherwise manual work. In both cases, the skill creators did the work once and made it easier for everyone else running the same migrations.
• • Patterns are spreading on their own. Engineers outside the workflow sessions are writing skills for other parts of their stack. One developer extended the design system workflow into a recursive orchestration agent, and skills built by one team are being picked up by others.
• • Context documentation is becoming part of the codebase. Teams are building Copilot instructions and skill reference files directly in repositories. Iteration, a core theme from foundational training, is now showing up in how these files evolve over time.
• • A foundation for autonomous coding. Advising on the internal autonomous coding effort gave the team a clear path from single-squad pilot to broader deployment.

What The Knot received. A shared foundation for AI-assisted engineering, grounded in five focused workflows that each produced reusable, in-repo skills the teams now own. The org moved from individual experimentation to structured, team-level practice, with skills crossing team boundaries and context files living in the codebases that need them.