Testing Strategies
ancoleman/ai-design-components
Strategic guidance for choosing and implementing testing approaches across the test pyramid.
Drive feature development using Outside-In TDD with Hexagonal Architecture.
Install Growing Outside In Systems
$ npx skills add lexler/skill-factory --skill growing-outside-in-systems -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install lexler/skill-factory growing-outside-in-systems --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ git clone --depth 1 https://github.com/lexler/skill-factory.git skills-src && mkdir -p .claude/skills && cp -r skills-src/output_skills/practices/growing-outside-in-systems .claude/skills/growing-outside-in-systems && rm -rf skills-srcUse ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.
Claude Code skills documentation · loads skills from .claude/skills/
Install the "growing-outside-in-systems" agent skill from https://github.com/lexler/skill-factory/tree/main/output_skills/practices/growing-outside-in-systems into .claude/skills/growing-outside-in-systems/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "growing-outside-in-systems", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/lexler/skill-factory/tree/main/output_skills/practices/growing-outside-in-systemsType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add lexler/skill-factory --skill growing-outside-in-systems -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install lexler/skill-factory growing-outside-in-systems --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/lexler/skill-factory.git skills-src && mkdir -p .agents/skills && cp -r skills-src/output_skills/practices/growing-outside-in-systems .agents/skills/growing-outside-in-systems && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "growing-outside-in-systems" agent skill from https://github.com/lexler/skill-factory/tree/main/output_skills/practices/growing-outside-in-systems into .agents/skills/growing-outside-in-systems/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "growing-outside-in-systems", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add lexler/skill-factory --skill growing-outside-in-systems -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install lexler/skill-factory growing-outside-in-systems --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/lexler/skill-factory.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/output_skills/practices/growing-outside-in-systems .cursor/skills/growing-outside-in-systems && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "growing-outside-in-systems" agent skill from https://github.com/lexler/skill-factory/tree/main/output_skills/practices/growing-outside-in-systems into .cursor/skills/growing-outside-in-systems/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "growing-outside-in-systems", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/lexler/skill-factory.git --path output_skills/practices/growing-outside-in-systems--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add lexler/skill-factory --skill growing-outside-in-systems -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install lexler/skill-factory growing-outside-in-systems --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/lexler/skill-factory.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/output_skills/practices/growing-outside-in-systems .gemini/skills/growing-outside-in-systems && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "growing-outside-in-systems" agent skill from https://github.com/lexler/skill-factory/tree/main/output_skills/practices/growing-outside-in-systems into .gemini/skills/growing-outside-in-systems/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "growing-outside-in-systems", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install lexler/skill-factory growing-outside-in-systemsInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add lexler/skill-factory --skill growing-outside-in-systems -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/lexler/skill-factory.git skills-src && mkdir -p .github/skills && cp -r skills-src/output_skills/practices/growing-outside-in-systems .github/skills/growing-outside-in-systems && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "growing-outside-in-systems" agent skill from https://github.com/lexler/skill-factory/tree/main/output_skills/practices/growing-outside-in-systems into .github/skills/growing-outside-in-systems/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "growing-outside-in-systems", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add lexler/skill-factory --skill growing-outside-in-systems -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install lexler/skill-factory growing-outside-in-systems --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/lexler/skill-factory.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/output_skills/practices/growing-outside-in-systems .opencode/skills/growing-outside-in-systems && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "growing-outside-in-systems" agent skill from https://github.com/lexler/skill-factory/tree/main/output_skills/practices/growing-outside-in-systems into .opencode/skills/growing-outside-in-systems/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "growing-outside-in-systems", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
Facts
- Skill name
growing-outside-in-systems- GitHub stars
- 239
- Used in
- 1 other repo
- Token cost
- ~1.9k tokens
- SKILL.md length
- 821 words
- Files
- 5 (incl. references)
- Skills in repo
- 25
- Repo updated
- First seen
- Licence
- Apache-2.0
At a glance
Drive feature development using Outside-In TDD with Hexagonal Architecture.
- Works in 5 steps: Inline — implement logic naively inside… → In-Memory adapter — once behavior is… → Interface — extract the adapter… → …
- Building features
- SKILL.md covers The Two Loops, Test Priorities, The Testing Matrix and Emergent Design Workflow, plus 8 more sections
- Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md
What it does
Growing Outside In Systems is an agent skill from lexler/skill-factory. Drive feature development using Outside-In TDD with Hexagonal Architecture. Design emerges through inline code, in-memory fakes, interface extraction, and deferred I/O. Use when building features, writing tests, or structuring backend services. Triggers on: TDD, outside-in, hexagonal, ports and adapters, emergent design, acceptance test, component test, walking skeleton, in-memory fakes, component, contract test, adapter, fast tests, sub-second feedback. Language-agnostic (Go, Rust, Python, TypeScript, Java, C).
Its SKILL.md is about 1.9k tokens, which your agent loads only when the skill is triggered. The skill folder holds 5 other files, including reference files (for example `references/folder-structure.md`, `references/glossary.md` and `references/methodology.md`).
It sits in Testing & QA, covering Test-driven development, End-to-end testing and Integration testing. It works with C#, Java, Python and Rust. The licence is Apache-2.0.
When your agent uses it
- Building features
- Structuring backend services
- Ports and adapters
- Emergent design
Example prompts
- “/growing-outside-in-systems”
Workflow steps
5 steps, taken from the first numbered list in SKILL.md.
- Inline — implement logic naively inside business code; use local variables, lists, maps; no abstractions
- In-Memory adapter — once behavior is verified, extract logic into a dedicated in-memory adapter implementation
- Interface — extract the adapter interface from what actually emerged (not theoretical guesses)
- Deferred I/O — implement the real adapter (database, network, file system) only after the API is mature
- Refactor the inline code inside the hexagon
What it can do on your machine
Read from SKILL.md and the folder at commit e262032. It shows what the files ask for, not the result of running them.
Tool permissions
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
Runs code
No scripts in the folder and no shell commands in SKILL.md.
From the folder's file list and the shell code blocks in SKILL.md.
Network
Links to these hosts (documentation or services it may open):
martinfowler.comgrowing-object-oriented-software.comshaiyallin.comalistair.cockburn.us
From URLs in SKILL.md, links to its own repository left out.
Credentials
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
Context cost
Growing Outside In Systems loads about 1.9k tokens when it runs, and up to ~7.1k if it reads all its reference files. Until then it costs about 136 tokens; SKILL.md has 821 words of instructions outside code blocks.
Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.
Safety
Auto-check passed
The automated check found no risky patterns in SKILL.md.
Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.
SKILL.md
The full file from lexler/skill-factory at commit e262032, republished under its Apache-2.0 licence (© lexler). 821 words, ~1,939 tokens.
Download SKILL.mdSave it as
.claude/skills/growing-outside-in-systems/SKILL.md (or your agent's skills folder). This skill also uses 4 other files; get the full folder from GitHub.- name
- growing-outside-in-systems
- description
- Drive feature development using Outside-In TDD with Hexagonal Architecture. Design emerges through inline code, in-memory fakes, interface extraction, and deferred I/O. Use when building features, writing tests, or structuring backend services. Triggers on: TDD, outside-in, hexagonal, ports and adapters, emergent design, acceptance test, component test, walking skeleton, in-memory fakes, component, contract test, adapter, fast tests, sub-second feedback. Language-agnostic (Go, Rust, Python, TypeScript, Java, C#).
STARTER_CHARACTER = 🔴🟢
Outside-In TDD with Hexagonal Architecture
Build features by driving design from the outside in. Every feature starts with a failing acceptance test. Design emerges through disciplined Red-Green-Refactor cycles. Infrastructure is deferred until the domain API is proven.
Unlike inside-out TDD with mocks, this approach tests behavior at the boundary — not implementation details — making the suite refactor-friendly by design. See methodology.md.
For canonical terms used throughout, see references/glossary.md.
The Two Loops
Outer loop (Acceptance test): Write a failing test scoped at the service/system boundary. This test exercises integration across Bounded Contexts using in-memory adapters. It defines "done."
Inner loop (Red-Green-Refactor): Cycles inside a Bounded Context to make the outer test pass. Drop into this loop only to implement what the acceptance test demands.
Every feature starts from the outside in. The acceptance test drives the process.
Test Priorities
Acceptance and component tests are the primary instruments. Unit tests are the exception.
- Acceptance tests — service/system boundary, in-process, in-memory adapters; read as specifications
- Component tests — single Bounded Context; drives internal module design via in-memory adapters
- Unit tests — exception only: well isolated ,genuinely complex, algorithmic, or combinatorial logic
See testing-strategy.md for full definitions, the testing matrix, and contract test patterns.
The Testing Matrix
| Fast | Slow | |
|---|---|---|
| Large Scope | Acceptance & Component — daily driver | E2E — minimize |
| Small Scope | Unit — use sparingly | Contract — CI only |
Sub-second feedback is non-negotiable. If tests take seconds, the team stops refactoring and the system decays.
Emergent Design Workflow
Follow this sequence strictly within each Bounded Context:
- Inline — implement logic naively inside business code; use local variables, lists, maps; no abstractions
- In-Memory adapter — once behavior is verified, extract logic into a dedicated in-memory adapter implementation
- Interface — extract the adapter interface from what actually emerged (not theoretical guesses)
- Checkpoint: all types in the interface must live inside the hexagon
- I/O Checkpoint: if no I/O and not out-of-process → keep inside hexagon; do not create a port
- Deferred I/O — implement the real adapter (database, network, file system) only after the API is mature
- Refactor the inline code inside the hexagon
The sequence is non-negotiable. Each step collects evidence about what the adapter actually needs. See methodology.md for detailed rationale and the walking skeleton.
Hexagonal Architecture
The Domain Layer is the center. All I/O lives behind adapter interfaces at the boundary.
Dependency Rule: Infrastructure(adapters) → Application(ports) → Domain (outer depends on inner, never reverse)
I/O Classification Rule: if it does not do I/O and does not run out-of-process → belongs inside the hexagon; otherwise → adapter.
Port-referenced types must live inside the hexagon. If a port signature references a type in the adapter layer, the hexagon depends outward — a violation.
Naming:
- Ports:
For[Something](e.g.,ForCalculatingTaxes,ForGettingTaxRates) - Adapters:
[Something]Adapter(e.g.,WebUIAdapter,SQLDatabaseAdapter)
See folder-structure.md for full folder structure, private/public hexagon split, cross-hexagon dependency rule, adapter design patterns, and test seams.
Show full SKILL.md (357 more words)Show less
In-Memory Fakes, Not Mocks
Use in-memory fakes for all adapter boundaries. Never mocks or stubs for domain-level testing.
Fakes are real implementations backed by simple data structures (maps, lists). They have actual behavior. Mocks only verify call sequences — they couple tests to implementation details and break on every refactor.
Contract tests verify the real adapter matches the fake's behavior. See testing-strategy.md.
Walking Skeleton
For new projects or major new components: build a minimal end-to-end implementation first to pay integration cost upfront. Once upright, pivot to the emergent design workflow. See methodology.md.
Composition Root (Configurator)
Wires all adapter interfaces at startup. Used in two contexts:
- Production: real adapter implementations (database, network, file system)
- Tests: in-memory adapter implementations → fast, deterministic test harness
The same business logic runs in both contexts — only the adapters differ.
Feature Implementation Order
- Write a failing acceptance test — defines "done"
- Drop into the inner loop — Red-Green-Refactor
- Follow the emergent design sequence — Inline → In-Memory → Interface → Deferred I/O
- Add component tests if needed — when a Bounded Context grows complex
- Add unit tests only when justified — complex algorithms, combinatorial logic
- Implement real adapters last — verify with contract tests against in-memory fakes
Listen to the Tests
Difficulty writing a test is a design signal, not a skill problem:
- Hard to set up → too many dependencies; split or rethink adapter boundaries
- Hard to assert on → API is hiding or tangling information callers need
- Fragile, breaks on refactor → testing implementation details; step up to component/acceptance test
- Slow → hitting real I/O; find the missing adapter boundary
Do not fight the tests. Reshape the code until the test is easy to write.
Reference Documentation
- glossary.md — canonical terms
- folder-structure.md — folder structure, private/public hexagon, cross-hexagon rules, adapter patterns, test seams
- testing-strategy.md — full testing matrix, acceptance/component test rules, contract test pattern
- methodology.md — why outside-in over regular TDD, walking skeleton, emergent design deep-dive, listen to the tests, anti-patterns
Sources
- Growing Object-Oriented Software, Guided by Tests — Steve Freeman & Nat Pryce (2009)
- Big Design Up-Front or Emergent Design? Hexagonal Architecture Gives Us Both — Shai Yallin (2020)
- Hexagonal Architecture — Alistair Cockburn (2005)
- Contract Test — Martin Fowler
- Component Test — Martin Fowler
- Bounded Context — Martin Fowler
© lexler, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file
Files
SKILL.md and 4 other files (references) in output_skills/practices/growing-outside-in-systems of lexler/skill-factory.
- SKILL.md
- references/folder-structure.md
- references/glossary.md
- references/methodology.md
- references/testing-strategy.md
Open the folder on GitHubat commit e262032
Used in 1 other repository
We found 1 copy of this SKILL.md (exact, near-identical or edited) in other folders, from 1 other GitHub owner. This page covers the copy in lexler/skill-factory, which our catalogue first saw on October 7, 2026.
Compare with similar skills
Growing Outside In Systems next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Growing Outside In Systems this skilllexler/skill-factory | 239 | 1 repos | ~1.9k | Automated safety check: Pass | Apache-2.0 | |
| Testing Strategiesancoleman/ai-design-components | 525 | — | ~3.8k | Automated safety check: Pass | MIT | |
| Polyglot Test Agentboshi-xixixi/TraeSkill | 276 | — | ~1.7k | Automated safety check: Pass | MIT | |
| Build Teaql Appteaql/teaql-agent-kit | 2.8k | — | ~4.6k | Automated safety check: Pass | MIT | |
| Java SDK E2E Test with Replay Snapshotgithub/copilot-sdk | 11k | — | ~1.8k | Automated safety check: Pass | MIT | |
| Supercovsupercorp-ai/supercov | 152 | 1 repos | ~415 | Automated safety check: Pass | MIT |
Similar skills
Polyglot Test Agent
boshi-xixixi/TraeSkill
Generates comprehensive, workable unit tests for any programming language using a multi-agent pipeline.
Build Teaql App
teaql/teaql-agent-kit
Build or change a TeaQL application in Java, Rust, Go, Swift, Python, C/.NET, or TypeScript, including Kotlin/JVM applications that consume Java-generated libraries.
- Official
Java SDK E2E Test with Replay Snapshot
github/copilot-sdk
Creates a Java SDK end-to-end test for the Copilot SDK that runs against a recorded YAML snapshot through a replay proxy, so CI needs no real authentication.
Supercov
supercorp-ai/supercov
Measures test coverage and code quality in a repository with the supercov CLI, and turns what it finds into small, focused tests or fixes.
Validation
josstei/maestro-orchestrate
Cross-cutting validation methodology for verifying phase outputs and project integrity
More from lexler/skill-factory
All 25 skills in this repoC4 Architecture Diagrams
lexler/skill-factory
Creates C4 model diagrams at every zoom level, from system landscape to code, in ASCII, Mermaid or Structurizr, for designing or documenting software architecture.
Launching Agent Teams
lexler/skill-factory
Plans and launches Claude Code agent teams with distinct roles, right-sized tasks and detailed spawn prompts, and says when subagents or worktrees fit better.
Claude Code Statusline Writer
lexler/skill-factory
Guides writing and debugging Claude Code status line scripts that read session JSON from stdin and print one line of text.
Augmented Coding Patterns Reference
lexler/skill-factory
Catalog of obstacles, anti-patterns and patterns for working with AI coding agents, covering context management and reliability, from a published patterns collection.
Approval Testing Toolkit
lexler/skill-factory
Writes snapshot-style approval tests in Python, JavaScript, TypeScript or Java, comparing output against an approved file instead of writing individual assertions.
Hotspots
lexler/skill-factory
Find where a codebase actually costs time by mining its git history (Tornhill hotspot analysis).
Related
Works with
Categories
Questions about Growing Outside In Systems
What does Growing Outside In Systems do?
Drive feature development using Outside-In TDD with Hexagonal Architecture. Growing Outside In Systems is an agent skill from lexler/skill-factory. Drive feature development using Outside-In TDD with Hexagonal Architecture.
When should I use Growing Outside In Systems?
Growing Outside In Systems fits situations like: building features; structuring backend services; ports and adapters; emergent design.
How do I install Growing Outside In Systems in Claude Code?
Run `npx skills add lexler/skill-factory --skill growing-outside-in-systems -a claude-code`. Or copy the skill folder (output_skills/practices/growing-outside-in-systems in lexler/skill-factory) into .claude/skills/growing-outside-in-systems in your project. Claude Code loads it when a task matches its description.
How do I install Growing Outside In Systems in Codex?
Run `npx skills add lexler/skill-factory --skill growing-outside-in-systems -a codex`. Or copy the skill folder (output_skills/practices/growing-outside-in-systems in lexler/skill-factory) into .agents/skills/growing-outside-in-systems in your project. Codex loads it when a task matches its description.
Can I use Growing Outside In Systems in Cursor, Gemini CLI or GitHub Copilot?
Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add lexler/skill-factory --skill growing-outside-in-systems -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/growing-outside-in-systems, .gemini/skills/growing-outside-in-systems, .github/skills/growing-outside-in-systems and .opencode/skills/growing-outside-in-systems in your project.
What does Growing Outside In Systems need to run?
SKILL.md names no scripts, command-line tools or credentials: Growing Outside In Systems is instructions for the agent only.
Does Growing Outside In Systems access the network?
SKILL.md names 4 domains. As links in the text: martinfowler.com, growing-object-oriented-software.com, shaiyallin.com and alistair.cockburn.us. This is read from the text; nothing was executed.
Is Growing Outside In Systems safe to install?
Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.
What licence does Growing Outside In Systems use?
Growing Outside In Systems is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.
How many tokens does Growing Outside In Systems use?
About 1.9k tokens (SKILL.md is roughly 7.8k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 5.2k tokens, read only when the agent opens those files.
What are the alternatives to Growing Outside In Systems?
Skills that share tags, products or a category with Growing Outside In Systems: Testing Strategies (ancoleman/ai-design-components, 525 stars), Polyglot Test Agent (boshi-xixixi/TraeSkill, 276 stars), Build Teaql App (teaql/teaql-agent-kit, 2.8k stars) and Java SDK E2E Test with Replay Snapshot (github/copilot-sdk, 11k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
Who maintains Growing Outside In Systems?
lexler (a GitHub user) maintains it in lexler/skill-factory, which has 239 GitHub stars. The repository holds 25 skills in this directory. The repository was last updated on October 10, 2026.
Source: lexler/skill-factory on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.