push-and-pull skill
✓ VerifiedImplements a test-driven development rhythm of pushing failing tests and pulling code to satisfy intended behavior.
- GitHub stars
- 113
- Files
- 1
- Last commit
- Nov 1, 2026
- License
- MIT
- Allowed tools
- —
What does the push-and-pull skill do?
push-and-pull implements a test-driven development rhythm of pushing failing tests and pulling code to satisfy intended behavior.
Summary generated from the skill's SKILL.md.
About the push-and-pull skill
Implementing a test-driven development rhythm by pushing failing tests and pulling code to satisfy intended behavior is the primary function of this skill. Developers use it to maintain discipline during TDD, regression testing, or bug fixing when a cheap local test target exists. An agent should load this skill when a user requests a failing test, asks for a red-green cycle, or needs to add a regression test for a specific bug.
The process follows a strict sequence of understanding behavior, choosing a narrow executable check, pushing a failing test, pulling the production code to pass, and finally settling through refactoring. It prioritizes testing observable behavior at the public surface rather than internal implementation details or private helpers. If a formal test is impractical due to slow infrastructure or brittle mocks, the skill directs the agent to use alternative checks like targeted scripts, manual reproduction commands, or log assertions.
This approach distinguishes itself by refusing to build bad tests that depend on timing, implementation details, or expensive setup. It requires the agent to report specific evidence, such as quoting the failure content before a fix and confirming the passing state after the implementation change.
What an agent can do with it
- 1Execute a TDD cycleWrite a failing test for a new feature and then implement the code to make it pass.
- 2Add a regression testCreate a focused test to ensure a specific bug does not return in future updates.
- 3Handle impractical test environmentsUse a manual command or script when a full unit test is too expensive or complex to set up.
- 4Verify test qualityCheck if a test is actually measuring behavior rather than implementation details.
Written from the skill's SKILL.md. Every use case is checked against a quote from it.
How to install the push-and-pull skill
Each command copies the skill folder into the client's skills directory. Restart the client or start a new session to load it.Install the push-and-pull skill in Plugin
/plugin marketplace add tmcfarlane/team-avatar /plugin install team-avatar@team-avatar
Install the push-and-pull skill in Claude Code
~/.claude/skills/push-and-pull/SKILL.md
$ npx degit tmcfarlane/team-avatar/plugins/team-avatar/skills/push-and-pull ~/.claude/skills/push-and-pullInstall the push-and-pull skill in Claude Code (project)
.claude/skills/push-and-pull/SKILL.md
$ npx degit tmcfarlane/team-avatar/plugins/team-avatar/skills/push-and-pull .claude/skills/push-and-pullInstall the push-and-pull skill in Codex
~/.agents/skills/push-and-pull/SKILL.md
$ npx degit tmcfarlane/team-avatar/plugins/team-avatar/skills/push-and-pull ~/.agents/skills/push-and-pullInstall the push-and-pull skill in Gemini CLI
~/.gemini/skills/push-and-pull/SKILL.md
$ npx degit tmcfarlane/team-avatar/plugins/team-avatar/skills/push-and-pull ~/.gemini/skills/push-and-pullInstall the push-and-pull skill in Claude.ai
npx degit tmcfarlane/team-avatar/plugins/team-avatar/skills/push-and-pull push-and-pull && zip -r push-and-pull.zip push-and-pull # claude.ai → Customize → Skills → + → Create skill → Upload a skill → push-and-pull.zip
Automated checks
Ran Nov 14, 2026Full report →Passed our automated checks. That is not a security audit: read the scripts before you let an agent run them. How checks work
- Source repository linked and reachabletmcfarlane/team-avatar/plugins/team-avatar/skills/push-and-pull is public and reachablegithub.com/tmcfarlane/team-avatar/tree/HEAD/plugins/team-ava ↗Pass
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit 2026-11-01github.com/tmcfarlane/team-avatar/commits ↗Pass
- No download-and-run or credential theft in scriptsNo scripts in the skill folderPass
- No hidden instructions in SKILL.mdNo override phrases, safeguard switches, credential requests or hidden charactersgithub.com/tmcfarlane/team-avatar/blob/HEAD/plugins/team-ava ↗Pass
- Pre-approved tools are scopedNo pre-approved tools; the agent asks before using onegithub.com/tmcfarlane/team-avatar/blob/HEAD/plugins/team-ava ↗Pass
- SKILL.md follows the Agent Skills formatValid name and description; says when to use it; 61 linesgithub.com/tmcfarlane/team-avatar/blob/HEAD/plugins/team-ava ↗Pass
SKILL.md
View on GitHubKatara's push and pull
Waterbending is a rhythm. Push, then pull. Test-first work is the same rhythm. Push a failing test that names the behavior. Pull the code until it passes. Then let the water settle and clean up.
When to push a new test
Write the test first when the user asks for TDD, a failing test, or a regression test, or when the bug has a clear, cheap test path. Make the broken behavior executable before you change production code. The goal is a focused regression test that fails before the fix and passes after it.
Do not force a test when it would be impractical. If the available test would need broad harness setup, brittle mocks, slow end-to-end infrastructure, production-only state, vague reproduction steps, or large unrelated fixture churn, skip the new test and use the closest useful check instead (see below).
The rhythm
- Understand the behavior. Name the intended behavior, the current behavior, the affected path, and the smallest observable reproduction.
- Choose the narrowest executable check. Prefer the closest unit, component, integration, or regression test the codepath already uses. If no practical test path is obvious, do not build one from scratch just to satisfy the rhythm.
- Push (red). Write the smallest test for one behavior a caller can observe, the one that would have caught the bug. It encodes intended behavior, not the current implementation.
- Run it before the fix. Confirm it fails for the intended reason. Quote the failure content, not the assertion line. An exception, an empty result against a literal, and the predicted mismatch all print red, and only the predicted mismatch proves the test measures the bug. An import error or a crash is not red. It is a broken instrument. If the test passes, or fails for an unrelated reason, correct the test or the reproduction before you touch the implementation.
- Pull (green). Make the smallest production change that satisfies the intended behavior and keeps nearby contracts. Rerun the new test, then the whole nearby suite.
- Settle (refactor). Clean the code with the tests green. Run them again after each change.
- Repeat for the next behavior. Commit at each green when the work spans several behaviors, and land the failing test in a commit before its fix.
When a failing test is impractical
Use the closest executable regression check instead: a targeted script, a manual reproduction command, browser automation, a snapshot comparison, a log assertion, or a focused integration check.
Prefer no new test over a bad test. A bad test mostly tests mocks, encodes implementation details, depends on timing or unrelated global state, needs expensive infrastructure for a small fix, or would be deleted right after it proved the fix.
What to test
- Behavior at the public surface. Inputs and outputs, side effects a caller sees, errors a caller handles. Not private helpers, call counts, or internal state.
- The bug's exact trigger. A regression test reproduces the reported input, not a cleaned-up approximation.
- The edges that matter. Empty, one, many, the boundary value, the error path. Skip edges no caller can reach.
- The real thing when cheap. Prefer a real database, filesystem, or process in a test container over a mock. Mock only what is slow, flaky, or external.
Check a test is worth keeping
- Revert the code change. Does the test fail? If not, it tests nothing.
- Rename an internal function. Does the test still pass? If not, it tests the implementation.
- Read the test name alone. Does it say what behavior is promised?
Rules
- Never change a test merely to match a wrong implementation.
- Never delete or weaken a failing test, or an existing assertion, to get green. Weaken an assertion only when the expected behavior has truly changed and the reason is clear.
- Keep a regression test focused on the bug. Avoid broad fixture churn or unrelated coverage.
- Never assert on log text, timing, or ordering the caller does not depend on.
- A flaky test is a bug. Make it deterministic where you can (shared state, real time, network) and name the signal it locks down, or quarantine it with an issue.
- When the bug exposes a broader class of failures, land the focused regression test first. Consider sibling coverage after.
Reply
Report the evidence, not only the outcome.
- Name the failing-before test or check and quote the failure it produced, trimmed to the diff.
- Name the passing-after run and any nearby checks you ran.
- If you could not show failing-before evidence, say why and name the closest regression check you used instead.
Files in this skill
1push-and-pull skill questions
How do I install the push-and-pull skill in Claude Code?
Run npx degit tmcfarlane/team-avatar/plugins/team-avatar/skills/push-and-pull ~/.claude/skills/push-and-pull. Claude Code loads skills from ~/.claude/skills (all projects) or .claude/skills (one project) and uses a skill when its description matches the task.
Which clients can use the push-and-pull skill?
Any client that reads the Agent Skills format: Claude Code, Codex, Gemini CLI and claude.ai (upload as a ZIP). Scripts in the skill run only where the client allows code execution.
When should I skip writing a new test?
Skip a new test if the path is unclear, expensive, integration-heavy, requires broad harness setup, or involves brittle mocks and slow infrastructure.
What should I test to ensure a good regression test?
Focus on behavior at the public surface, such as inputs, outputs, side effects, and errors, rather than private helpers or internal state.
How can I tell if a test is testing implementation instead of behavior?
If the test fails when you rename an internal function, it is testing the implementation rather than the behavior.