How I Structure the AI Function at Challenger Brands Serious About Using LLMs to Get Ahead

By Doug Silkstone | March 10, 2025

After 15 years building automation systems, I’ve developed some opinions about what actually works. This is the blueprint I’ve been using with teams who want to move fast without getting caught up in hype. Take what’s useful, adapt it to your needs, and let me know how it goes.

Here’s what I’m seeing: Teams have ChatGPT licenses, Zapier subscriptions, multiple no-code platforms, but they’re struggling to get real value. The automations they build get lost, forgotten, or can’t be reused by other teams. What’s been working for me is thinking about architecture first, tools second. Imagine having a structured approach where every automation becomes discoverable and reusable—like Storybook for AI automation. A living catalog where your team’s work compounds instead of getting buried. Here’s the approach I’ve been using—feel free to adapt it to your situation.

Start Here: Code Blocks as Your Foundation (Not Another Platform)

Key principle: Start with simple, atomic code blocks that solve real problems. One input, one output, one clear purpose. You can always add complexity later.

These blocks handle everything from basic tasks to complex operations:

Basic Operations

Send emails
Create tickets
Post to Slack
Update spreadsheets

Complex Processing

Pull Shopify analytics
Process Stripe invoices
Execute SQL queries
Run ML models

The key is standardization—every block follows the same pattern:

interface CodeBlock {
  input: ZodSchema
  handler: async (input) => output
  output: ZodSchema
  metadata: {
    name: string
    description: string
    category: string
    version: string
  }
}

Platform Flexibility: The Game Changer

Every component lives in a central registry that automatically generates production-ready infrastructure. This ensures both developers and no-code users have equal access to your organization’s automation capabilities.

Why Most AI Implementations Struggle

According to Red Hat’s research, 77% of IT professionals consider automation essential, yet most implementations fail. The problem? Focusing on tools rather than architecture.

The statistics tell a stark story:

Success Metric	Winners	Losers	Gap
Process Automation	20M records/year	<100K records/year	200x
Time Savings	100,000+ hours	<1,000 hours	100x
ROI	300-500%	Negative	∞
Adoption Rate	>80% of employees	<10% of employees	8x

The Platform Comparison Reality

Best for: Complex, custom AI workflows

500+ integrations
Code flexibility
Self-hostable (Enterprise options available)
LangChain nodes for LLM apps
Pay per execution, not per step

Limitation: Requires technical expertise

What I’ve found is that teams need a structured methodology that works across their existing platforms. A practical way to create, document, test, and share automation components that any motivated team member can understand and use.

Building Your Component Registry: A Practical Approach

What’s worked well for me is starting with a straightforward component registry that serves as the central hub for all automation efforts. I’ve implemented this approach at several companies, and it’s been consistently effective. This registry isn’t just documentation—it’s an active system that:

Makes every automation component discoverable across teams
Provides crystal-clear usage instructions and examples
Enables interactive testing before integration
Automatically generates integration points for any platform

Think of it as building a workshop for AI components, where teams can develop and test automation in isolation before deploying at scale. The goal is to create repeatable systems that compound value over time instead of starting from scratch with each new project.

Common Pitfalls and How to Avoid Them

After working with dozens of teams on AI implementations, I’ve noticed four patterns that consistently cause problems. Here’s what to watch out for:

🏝️ The Silo Trap

Problem: Teams build in isolation. Appolica engineers boosted productivity 2x with AI tools but couldn’t share gains company-wide.Impact: 70% of automation value trapped in individual teamsSolution: Mandate every automation becomes a reusable component from inception. No exceptions.

policy:
  all_automations:
    must_register: true
    must_document: true
    must_test: true

♻️ The Duplication Death Spiral

Problem: Same solutions built repeatedly. One Fortune 500 built the same Slack integration 7 times.Impact: 5-10x wasted development effortSolution: Registry with mandatory search before new development.

// Before creating any component:
const existing = await registry.search({
  functionality: 'slack notification',
  department: 'any'
})
if (existing.length > 0) {
  useExisting(existing[0])
}

🔌 The Integration Nightmare

📚 The Knowledge Black Hole

Problem: Undocumented automations die in darkness.Impact: 90% of components never reusedSolution: Documentation-as-code with enforcement.

@Component({
  name: 'Invoice Processor',
  description: 'Processes Stripe invoices and updates CRM',
  examples: [
    { input: sampleInvoice, output: expectedResult }
  ],
  sla: '99.9% uptime, &lt;500ms response'
})
class InvoiceProcessor {
  // Won't compile without decorator metadata
}

Four Pillars for Success

Here’s the framework that’s been working well for the teams I’ve worked with:

1. Democratized Creation with Structure

Everyone can contribute automations, but within a clear framework. At Roo, this approach helped them double their output without adding engineers. The key is making component creation accessible to non-technical team members while maintaining production standards.

2. Modular Architecture

Instead of monolithic platforms, focus on building composable blocks that your team will actually use:

Self-Describing: Components explain themselves through schemas
Platform-Agnostic: Works in code, no-code, or hybrid environments
Instantly Testable: Validate behavior before integration
Auto-Documented: Documentation generated from code, not maintained separately

3. The Registry as a Value Center

The component registry becomes more than infrastructure—it’s an asset that drives value. One team I worked with now processes $2M in monthly transactions through their registry with minimal maintenance:

Discovery Engine: AI-powered search finds components by describing what you need
Automatic API Generation: Every component becomes an endpoint instantly
Version Control Built-In: Track changes, dependencies, and compatibility automatically
Security by Design: Role-based access control at the component level
Performance Monitoring: Know which components deliver value, which need optimization

Core registry requirements:

TypeScript/Zod schemas for type safety
GraphQL interface for flexible querying
Git-based versioning for complete history
Automated testing on every change
SLA tracking for mission-critical components

4. Production-Ready From the Start

Rather than building proof of concepts that get stuck, aim to ship production-ready components from day one:

Swagger UI for interactive exploration
Automatic cloud exposure via secure tunneling
Load balancing and queue management built-in
Monitoring and alerting out of the box

The Real Impact (With Actual Numbers)

For Individual Contributors

Stop reinventing wheels—discover what exists instantly
Ship features 10x faster using pre-built components
Focus on business logic, not boilerplate
Contribute improvements that benefit everyone

As documented in Microsoft’s real-world automation stories, teams that adopt component-based approaches see dramatic productivity gains.

For Engineering Teams

Establish and enforce standards automatically
Eliminate duplicate work across departments
Ship with confidence—everything is pre-tested
Scale teams without scaling headcount

For Leadership

Direct line-of-sight from automation to business impact
Quantifiable ROI on every automation investment
Compressed time-to-market for new capabilities
Transform fixed costs into variable wins

Here’s what’s been working well for me and the teams I work with:

Type Safety: The Foundation

When you’re building LEGO blocks, you need to know their shape, size, color, and how they fit together. That’s where TypeScript + Zod comes in. Zod gives you blazing-fast runtime validation (100K+ objects/second) and auto-generates TypeScript types from your schemas. It’s perfect for defining component interfaces—making your automation blocks snap together perfectly every time.

API Layer: Hono

For the API layer, I use Hono. It’s a small, fast web framework that runs anywhere—Cloudflare Workers, Deno, Bun, Node.js. The TypeScript-first design means you get type safety from edge to edge, and at 12KB, it’s incredibly lightweight. The developer experience is fantastic, and it just works.

Documentation That Actually Gets Read

OpenAPI/Scalar

For API documentation:

Scalar creates beautiful, interactive API docs
OpenAPI spec for standards compliance
Auto-generates client SDKs
Try-it-now functionality

Mintlify

For user documentation:

You’re reading this on Mintlify right now!
MDX-powered documentation
Beautiful out of the box
Great search and navigation

Job Queue Options

For orchestrating your automation components, here are the platforms I recommend:

BullMQ - Rock-solid Redis-based queues

Battle-tested in production
Excellent TypeScript support
Dashboard UI available
Handles millions of jobs daily

The Key Principle

Once you have your compendium of components and you’re ready for existing challenges, adding new LEGO blocks becomes trivial. As new tech emerges, you can integrate it as just another block in your system—no need to rebuild everything.

Implementation Timeline

Timeline: With this setup, components typically go from code to production in under 10 minutes.

Essential Terminology for AI Functions

Code Block: Atomic unit of automation—single input, single output, single purpose
Component: Orchestrated collection of blocks solving a business problem
Registry: Living catalog of all organizational automation assets
Schema: Contract defining how components communicate
Adapter: Bridge between your components and external platforms
Pipeline: Chain of components processing data sequentially

KPIs That Actually Matter

Most companies track vanity metrics. Here are the KPIs that predict real success:

🔄 Reuse Ratio

Target: >70%Components used by 2+ teamsWhy it matters: Indicates true platform value

⚡ Time-to-Production

Target: <4 hoursIdea → deployed automationWhy it matters: Speed determines adoption

📊 Coverage Rate

Target: >80%Processes with automation availableWhy it matters: Shows strategic completeness

🚀 Adoption Velocity

Target: +10/weekNew active component creatorsWhy it matters: Momentum predicts success

The Value Multiplication Formula

const componentValue = {
  developmentCost: 10_000,      // One-time
  timeSavedPerUse: 2,           // Hours
  hourlyRate: 150,              // Dollars
  usesPerMonth: 50,             // Across org

  monthlyROI: function() {
    return (this.timeSavedPerUse * this.hourlyRate * this.usesPerMonth)
           - (this.developmentCost / 12)
  },

  annualMultiplier: function() {
    return (this.monthlyROI() * 12) / this.developmentCost
  }
}

// Result: 17x annual return on investment

Real Example: One payment processing component at a fintech saved $2.3M annually after 8 hours of development

Bridging Strategy and Execution

One of the biggest challenges is aligning what leadership envisions with what’s technically feasible. Here’s how this architecture helps bridge that gap:

Level	Traditional Problem	This Architecture’s Solution
C-Suite	”We’re doing AI” with no measurable impact	Direct metrics linking automation to revenue/cost
Management	Can’t standardize or scale initiatives	Central registry enforces standards automatically
Contributors	Building in isolation, zero visibility	Every creation immediately available company-wide

What I find encouraging is when unexpected collaborations emerge. Recently, a junior developer at one of the companies I work with built a component that now powers their CFO’s revenue dashboard, replacing an expensive SaaS solution. That’s the kind of democratization that makes this approach worthwhile.

Moving Forward: Why Timing Matters

The gap between companies effectively using AI and those still experimenting is widening. The good news is that with the right architecture, you can catch up quickly.

After implementing AI systems across dozens of organizations, the pattern is clear:

Treat AI as strategic platform
Component-first architecture
10-50x productivity gains
Compound value creation
Market leadership positions

A Practical 30-Day Implementation Plan

Here’s an approach that’s worked well for teams getting started:

Week 1: Assessment and Quick Win

Map out your current automation landscape
Identify one high-impact process to improve
Build your first reusable code block
Document the time or cost savings

Week 2: Build the Foundation

Set up TypeScript + Zod for your registry
Convert 5 existing automations to components
Create auto-generated API documentation
Demo the speed improvement to key stakeholders

Week 3: Expand the Team

Onboard a few motivated team members
Help them build components for their workflows
Track and document the impact
Consider internal billing to show value

Week 4: Solidify Support

Present measurable results to leadership
Propose next quarter’s roadmap
Consider bringing in dedicated resources
Set realistic but ambitious goals

📹 Learn More

Watch real implementation case studies and technical deep-dives

📧 Get Help

Schedule a consultation to architect your AI function

Final thought: This approach has helped several teams move from scattered experiments to cohesive AI capabilities. If you find these ideas useful, I’d love to hear how you adapt them to your situation.

If you’re working on building an AI function at your company and want to compare notes or discuss implementation details, feel free to reach out. I enjoy hearing how different teams approach these challenges. doug@withseismic.com or LinkedIn.

Insights

​How I Structure the AI Function at Challenger Brands Serious About Using LLMs to Get Ahead

​Start Here: Code Blocks as Your Foundation (Not Another Platform)

Basic Operations

Complex Processing

​Why Most AI Implementations Struggle

​The Platform Comparison Reality

​Building Your Component Registry: A Practical Approach

​Common Pitfalls and How to Avoid Them

​Four Pillars for Success

​1. Democratized Creation with Structure

​2. Modular Architecture

​3. The Registry as a Value Center

​4. Production-Ready From the Start

​The Real Impact (With Actual Numbers)

​For Individual Contributors

​For Engineering Teams

​For Leadership

​The Technical Stack I Recommend

​Type Safety: The Foundation

​API Layer: Hono

​Documentation That Actually Gets Read

OpenAPI/Scalar

Mintlify

​Job Queue Options

​The Key Principle

​Implementation Timeline

​Essential Terminology for AI Functions

​KPIs That Actually Matter

🔄 Reuse Ratio

⚡ Time-to-Production

📊 Coverage Rate

🚀 Adoption Velocity

​The Value Multiplication Formula

​Bridging Strategy and Execution

​Moving Forward: Why Timing Matters

​A Practical 30-Day Implementation Plan

📹 Learn More

📧 Get Help

How I Structure the AI Function at Challenger Brands Serious About Using LLMs to Get Ahead

Start Here: Code Blocks as Your Foundation (Not Another Platform)

Why Most AI Implementations Struggle

The Platform Comparison Reality

Building Your Component Registry: A Practical Approach

Common Pitfalls and How to Avoid Them

Four Pillars for Success

1. Democratized Creation with Structure

2. Modular Architecture

3. The Registry as a Value Center

4. Production-Ready From the Start

The Real Impact (With Actual Numbers)

For Individual Contributors

For Engineering Teams

For Leadership

The Technical Stack I Recommend

Type Safety: The Foundation

API Layer: Hono

Documentation That Actually Gets Read

Job Queue Options

The Key Principle

Implementation Timeline

Essential Terminology for AI Functions

KPIs That Actually Matter

The Value Multiplication Formula

Bridging Strategy and Execution

Moving Forward: Why Timing Matters

A Practical 30-Day Implementation Plan