mikeparcewski/wicked-garden / skills/agentic/frameworks
wicked-garden-agentic-frameworks
VerifiedUse when selecting or comparing agentic frameworks (LangChain, LangGraph, CrewAI, AutoGen, etc.) — curated comparison by use case, language, and maturity. Gets latest context via Context7 when available. NOT for reviewing existing agentic code (use review-methodology) or architecture patterns (use agentic-patterns).
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 7.2 KB |
| refs/framework-profiles-1.md | markdown | 5.3 KB |
| refs/framework-profiles-2.md | markdown | 6.1 KB |
| refs/migration-patterns-paths.md | markdown | 6.5 KB |
| refs/migration-patterns-testing.md | markdown | 5.0 KB |
refs/migration-patterns-testing.md
View on GitHub---
phase_relevance: ["design", "review"]
archetype_relevance: ["*"]
---
# Framework Migration Patterns: Testing, Rollback & Advanced Paths
Migration testing strategy, rollback planning, advanced migration paths, effort estimates, and when not to migrate.
## Advanced Migration Paths
### 5. Python Framework -> ADK (TypeScript)
**Scenario:** Migrating Python codebase to TypeScript.
**Motivation:**
- Team transitioning to TypeScript
- Want ADK's production features
- Building on Claude exclusively
**Strategy:**
**Step 1:** Port Agent Logic
```python
# Before: Python (any framework)
class ReviewAgent:
def review(self, code):
return llm.generate(f"Review: {code}")
# After: TypeScript (ADK)
const reviewAgent = new Agent({
name: 'reviewer',
instructions: 'You review code.',
model: 'claude-opus-4-6'
});
```
**Step 2:** Port Tools
```python
# Before: Python
def analyze_code(code: str) -> dict:
return {"issues": [...]}
# After: TypeScript
const analyzeCodeTool = {
name: 'analyze_code',
description: 'Analyze code for issues',
parameters: {
type: 'object',
properties: {
code: { type: 'string' }
}
},
handler: async (params: { code: string }) => {
return { issues: [...] };
}
};
```
**Gotchas:**
- Async patterns differ (promises vs async/await)
- Type systems differ
- Tool definitions have different formats
- Testing frameworks differ
**Effort:** High (4-8 weeks for large codebase)
### 6. Single-Provider -> Multi-Provider
**Scenario:** Locked into one LLM provider, want flexibility.
**Motivation:**
- Want to A/B test providers
- Cost optimization
- Failover capability
**Strategy:**
**Step 1:** Abstract LLM Client
```python
# Before: Direct provider calls
response = anthropic.messages.create(...)
# After: Abstracted
class LLMClient:
def generate(self, messages, model):
if model.startswith('claude'):
return self._call_anthropic(messages, model)
elif model.startswith('gpt'):
return self._call_openai(messages, model)
```
**Step 2:** Use Multi-Provider Framework
```python
# LangChain/LangGraph support multiple providers
from langchain_anthropic import ChatAnthropic
from langchain_openai import ChatOpenAI
llm = ChatAnthropic(model="claude-opus-4")
# Or
llm = ChatOpenAI(model="gpt-4-turbo")
```
**Gotchas:**
- Different providers have different features
- Output formats may vary
- Cost per token differs
- Rate limits differ
**Effort:** Low-Medium (1-2 weeks)
## Migration Testing Strategy
### 1. Equivalence Testing
Run both old and new system in parallel, compare outputs:
```python
async def equivalence_test(input):
old_result = await old_agent.process(input)
new_result = await new_agent.process(input)
similarity = compare_outputs(old_result, new_result)
if similarity < 0.9:
log_discrepancy(input, old_result, new_result)
return similarity
```
### 2. Shadow Testing
Route production traffic to both, use old result:
```python
async def shadow_process(input):
# Production (old)
result = await old_agent.process(input)
# Shadow (new) - don't await
asyncio.create_task(new_agent.process(input))
return result
```
### 3. Gradual Rollout
Slowly increase traffic to new system:
```python
async def gradual_rollout(input, percentage=10):
if random.random() * 100 < percentage:
return await new_agent.process(input)
else:
return await old_agent.process(input)
```
## Rollback Planning
Always have a rollback plan:
1. **Feature Flags:** Quick disable of new system
2. **Version Routing:** Route to old version instantly
3. **Database Compatibility:** Ensure schemas compatible
4. **Monitoring:** Alert on regressions immediately
```python
class FeatureFlag:
def __init__(self):
self.use_new_agent = False
async def process(self, input):
if self.use_new_agent:
return await new_agent.process(input)
else:
return await old_agent.process(input)
```
## Migration Effort Estimates
| Migration Path | Typical Effort | Risk Level |
|----------------|----------------|------------|
| Custom -> Framework | 2-4 weeks | Medium |
| LangChain -> LangGraph | 1-2 weeks | Low |
| CrewAI -> LangGraph | 2-3 weeks | Medium |
| AutoGen -> LangGraph | 3-4 weeks | Medium |
| Python -> TypeScript (ADK) | 4-8 weeks | High |
| Single -> Multi-Provider | 1-2 weeks | Low |
## Post-Migration Checklist
- [ ] All tests passing
- [ ] Equivalence testing shows >95% similarity
- [ ] Performance metrics maintained or improved
- [ ] Cost per request unchanged or improved
- [ ] Monitoring and alerting migrated
- [ ] Documentation updated
- [ ] Team trained on new framework
- [ ] Old code removed or archived
- [ ] Rollback plan tested
## When NOT to Migrate
Don't migrate if:
- Current system is stable and meets needs
- Migration cost exceeds benefits
- Team lacks expertise in target framework
- No clear improvement in capabilities
- Close to sunsetting the product
- Migration would delay critical features
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness. | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is available | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |