agent-loop-ext
Crash-resilient external agent loop with state persistence and CI/CD integration
Contribute a user's AIWG customization back upstream as a PR — reviews for general applicability, creates branch, opens PR
$ npx -y skills add jmagly/aiwg --skill customize-contribute-back --agent claude-codeHow it fires
How this skill gets triggered: by you, by Claude, or both.
/customize-contribute-backContext preview
The summary Claude sees to decide when to auto-load this skill.
Contribute a user's AIWG customization back upstream as a PR — reviews for general applicability, creates branch, opens PR
namespace: aiwg name: customize-contribute-back platforms: [all] description: Contribute a user's AIWG customization back upstream as a PR — reviews for general applicability, creates branch, opens PR
You help users contribute a customization from their fork back to the upstream AIWG repo. You first assess whether the customization is generally useful (not just personal), then create a feature branch, commit, and open a PR.
| Pattern | Example | Action | |---------|---------|--------| | Explicit PR | "PR this back to AIWG" | Assess → branch → PR | | Contribution question | "could this be useful for everyone?" | Assess only, ask to proceed | | Submit | "submit this skill upstream" | Assess → branch → PR |
When triggered:
1. **Identify what to contribute** — ask if not clear: > "Which customization would you like to contribute? (e.g., the domain-specialist agent, the my-conventions rule)"
2. **Assess for general applicability**:
If personal: decline gracefully: > "This looks specific to you — it references [X]. That's perfect as a private customization but wouldn't be a fit for the main repo. Keep it in your fork."
If general: confirm with user before proceeding: > "This looks generally useful. Want me to open a PR to jmagly/aiwg?"
3. **Create feature branch**:
git -C <edgePath> checkout -b feat/contribute-<name> git -C <edgePath> add <file(s)> git -C <edgePath> commit -m "<conventional-commit-message>" git -C <edgePath> push origin feat/contribute-<name>
Conventional commit format: `feat(<scope>): <description>` — scope is the addon/framework area (e.g., `aiwg-utils`, `sdlc`, `skills`).
4. **Open PR** via `gh`:
gh pr create \
--repo jmagly/aiwg \
--head <user>:feat/contribute-<name> \
--title "<conventional commit title>" \
--body "<description>"PR body template:
## Summary [What this adds/changes and why it's useful for AIWG users generally] ## Changes - [File: what it does] ## Testing - Deployed locally via `aiwg use all` - [Any specific testing done]
5. **Report**:
PR opened: https://github.com/jmagly/aiwg/pull/NNN Title: feat(aiwg-utils): [title] Branch: feat/contribute-<name> The PR is ready for review. You can continue customizing on main — this branch is separate.
**User**: "I built a terraform-specialist agent — could this be useful for others?"
**Assessment**: Not user-specific, generally useful for infra teams → confirm
**Action**: Create branch → commit `feat(aiwg-utils): add terraform-specialist agent` → push → `gh pr create`
**Response**: "PR opened at jmagly/aiwg. The Terraform specialist agent looks like a solid contribution."
**User**: "PR my my-conventions rule back to AIWG"
**Assessment**: File contains "always know I'm Joe from Acme Corp" — personal
**Response**: "This rule references you by name and mentions Acme Corp — it's a perfect personal customization but not a fit for the main repo where it wouldn't apply to other users. It stays in your fork."
**User**: "I improved the aiwg-sync skill to handle more edge cases — contribute it?"
**Assessment**: Improvement to existing skill, generally applicable → confirm
**Action**: Create branch → commit → PR
Reusable project context and specialist workflows for the AI tools you already use. Plan software, coordinate specialist reviews, prepare campaigns, investigate incidents, organize research, curate media, and maintain operational knowledge.
Repo: jmagly/aiwg
Crash-resilient external agent loop with state persistence and CI/CD integration
Detect requests for iterative autonomous agent loops and route to the appropriate loop executor
Automatically execute tests when code-generating agents modify source files, enforcing the execute-before-return pattern
Enable agent loops to learn from similar past tasks and share patterns across loops
Query and manage the executable feedback debug memory
Execute tests on generated code and iterate until passing