Building an AI Agency from Prompt Templates: Inside agency-agents

Hook

A repository with zero Python, JavaScript, or Go code has accumulated nearly 100,000 GitHub stars—more than many production-grade frameworks. The secret? It's selling something engineers hate building from scratch: well-structured prompts.

Context

Every development team using AI coding assistants faces the same awkward moment: someone asks Claude or Copilot to "make this component better" and gets generic, unusable output. Then a senior engineer steps in, writes a detailed prompt with context, constraints, and expected deliverables, and suddenly the AI produces something mergeable. The problem isn't the AI—it's that most developers are terrible at prompt engineering, and the few who excel at it are recreating the same specialized prompts across different tools and projects.

The agency-agents repository emerged from this frustration, specifically from Reddit communities where developers shared their most effective prompts for recurring tasks. Instead of treating prompts as throwaway text, creator Marek Sitarzewski structured them as reusable agent profiles—complete with personality traits, workflows, and quality standards. Each agent represents a specialized role: frontend engineers who obsess over accessibility, backend architects who prioritize scalability, or even "reality checkers" who challenge assumptions before you commit to bad decisions. The genius is in the packaging: these aren't just prompts, they're plug-and-play team members that work across Claude, Cursor, Copilot, Aider, and eight other AI tools.

Technical Insight

The repository's architecture is deceptively simple but thoughtfully designed. At its core are markdown files defining agent personas, each following a consistent structure that separates personality from process. Here's what a typical agent definition looks like:

# Frontend Accessibility Wizard

## Personality
- Passionate about inclusive design
- Patient with edge cases
- Speaks in terms of user impact, not compliance checkboxes

## Technical Expertise
- WCAG 2.1 AA/AAA standards
- ARIA patterns and semantic HTML
- Screen reader testing (NVDA, JAWS, VoiceOver)
- Keyboard navigation patterns

## Workflow
1. Audit existing component for accessibility violations
2. Prioritize fixes by user impact (critical path first)
3. Implement semantic HTML structure
4. Add appropriate ARIA labels where semantic HTML insufficient
5. Test with actual assistive technology
6. Document accessibility features for design system

## Deliverables
- Fully accessible component with semantic markup
- ARIA annotations with inline comments explaining purpose
- Keyboard navigation test cases
- Screen reader testing notes

The magic happens in the conversion layer. Shell scripts in /scripts parse these markdown templates and transform them into platform-specific formats. For Claude, that means converting to .clinerules files with specific formatting requirements. For Cursor, it's .cursorrules files with different syntax. Here's a simplified version of the conversion logic:

#!/bin/bash
# convert_to_claude.sh

AGENT_FILE=$1
OUTPUT_DIR="$HOME/.config/claude/agents"

# Extract agent name from filename
AGENT_NAME=$(basename "$AGENT_FILE" .md)

# Convert markdown to Claude format
# Remove markdown headers, format personality as system context
sed 's/^## Personality$/AGENT_CONTEXT:/' "$AGENT_FILE" | \
sed 's/^## Workflow$/PROCESS:/' | \
sed 's/^## Deliverables$/EXPECTED_OUTPUT:/' > \
"$OUTPUT_DIR/${AGENT_NAME}.clinerules"

echo "Installed $AGENT_NAME for Claude"

What makes this approach powerful is the structured thinking embedded in each template. The "Reality Checker" agent, for instance, doesn't just say "check for problems." It defines a systematic interrogation process: identify assumptions, demand evidence for claims, surface edge cases, and challenge technical decisions with specific questions about scalability, security, and maintainability. When you invoke this agent before a major refactor, you're not getting random skepticism—you're getting a checklist refined through dozens of real projects.

The repository also includes meta-agents that coordinate other agents. A "Project Planner" agent doesn't write code but orchestrates which specialized agents to involve at different project phases. During scaffolding, it might invoke the "Architecture Prophet" to design system boundaries. During implementation, it routes frontend work to the "UI Perfectionist" and backend work to the "API Guardian." This compositional pattern turns individual prompts into something resembling a workflow engine.

The installation scripts handle the tedious work of finding configuration directories across operating systems and tools. A master installer detects which AI coding tools you have installed and offers to configure all of them at once:

# install.sh excerpt
for tool in claude cursor copilot aider; do
  if command -v $tool &> /dev/null; then
    echo "Found $tool, installing agents..."
    ./scripts/convert_to_${tool}.sh agents/*.md
  fi
done

This cross-platform compatibility is why the repository gained traction. Developers switching from Copilot to Cursor or trying Claude alongside their existing setup can bring their entire agent library with them, maintaining consistency in AI output quality regardless of the underlying tool.

Gotcha

The fundamental limitation is inherent to prompt engineering itself: these templates are instructions, not guarantees. A beautifully crafted "Security Auditor" prompt might identify SQL injection risks when run against GPT-4, miss them entirely with GPT-3.5, and hallucinate false positives with a different model. You're still at the mercy of the underlying AI's capabilities, training data, and context window limitations. If your AI tool doesn't understand modern React patterns, no amount of prompt refinement will make it write good React code.

More subtly, highly structured prompts can create rigidity that fights against the creative exploration AI excels at. The "Frontend Wizard" agent might deliver pixel-perfect implementations of specified designs but completely miss suggesting a better UX approach that wasn't in the prompt. You're trading variance for consistency, which is usually what you want in production workflows, but occasionally you need the AI to challenge the premise of your request. The repository's agents are optimized for execution, not ideation. Additionally, as AI models evolve and capabilities shift, these prompts will require maintenance. A prompt engineered for Claude 2 might be verbose and inefficient with Claude 3's improved instruction-following, or might fail to leverage new features like extended context windows or vision capabilities.

Verdict

Use if: You're working with AI coding assistants on a team that needs consistent output quality, you find yourself repeatedly explaining the same context to AI tools, you switch between multiple AI coding tools and want portable agent configurations, or you want battle-tested prompt patterns instead of learning prompt engineering through trial and error. This repository is essentially a cheat code for teams that have already committed to AI-assisted development and need to standardize how they interact with these tools. Skip if: You prefer minimal, exploratory prompting where you guide the AI conversationally rather than through rigid structures, you're only using one AI tool and are happy with its native features, you haven't yet adopted AI coding assistants in your workflow (start simpler before investing in specialized agents), or you're looking for actual executable agent frameworks with tool integration and autonomous capabilities rather than prompt templates. The repository shines in reducing the cognitive overhead of context-switching between different specialized tasks, but it won't magically compensate for a weak underlying model or replace the judgment needed to evaluate AI-generated code.