メニュー
Enterprise EARS (Evaluate, Analyze, Recommend, Synthesize) Framework with AI-powered requirements engineering, Context7 integration, and intelligent solution orchestration for systematic problem-solving
デフォルトでは、最初にソースを確認する Prompt が選択されています。直接コマンドに切り替えるか、ローカルコピーをダウンロードすることもできます。
インストールを決める前に、SKILL.md と SkillsMP に表示されている付属ファイルをお読みください。
SOC 職業分類に基づく
Codex または Claude でインストール この Prompt をコピーして Codex、Claude、または他のアシスタントに貼り付けると、Skill ページを確認してインストールできます。
直接コマンドでは確認用 Prompt が省略されます。実行前にソースを確認してください。
npx skills add https://github.com/AJBcoding/claude-skill-eval --skill moai-foundation-earsコマンドは1行のまま表示されます。コピー前に横へスクロールして全体を確認してください。
ローカルで確認しますか？SkillsMP が現在取得できるファイルをダウンロードできます。
SKILL.md を表示中
Enterprise database architecture specialist with PostgreSQL 17, MySQL 8.4 LTS, MongoDB 8.0, Redis 7.4 expertise. Master connection pooling, query optimization, caching strategies, and database DevOps automation. Build scalable, resilient database systems with comprehensive monitoring and disaster recovery.
Enterprise Frontend Development with AI-powered modern architecture, Context7 integration, and intelligent component orchestration for scalable user interfaces
Enterprise-grade security expertise with production-ready patterns for OWASP Top 10 2021, zero-trust architecture, threat modeling (STRIDE, PASTA), secure SDLC, DevSecOps automation, cloud security, cryptography, identity & access management, and compliance frameworks (SOC 2, ISO 27001, GDPR, CCPA).
| name | moai-foundation-ears |
| version | 4.0.0 |
| created | 2025-11-11T00:00:00.000Z |
| updated | 2025-11-13T00:00:00.000Z |
| status | stable |
| description | Enterprise EARS (Evaluate, Analyze, Recommend, Synthesize) Framework with AI-powered requirements engineering, Context7 integration, and intelligent solution orchestration for systematic problem-solving |
| keywords | ["ears","requirements-engineering","systematic-thinking","problem-solving","evaluation-framework","context7-integration","ai-orchestration","production-deployment"] |
| allowed-tools | ["Read","Bash","Write","Edit","Glob","Grep","WebFetch","mcp__context7__resolve-library-id","mcp__context7__get-library-docs"] |
| Field | Value |
|---|---|
| Skill Name | moai-foundation-ears |
| Version | 4.0.0 (2025-11-13) |
| Tier | Foundation Framework Expert |
| AI-Powered | ✅ Context7 Integration, Intelligent Analysis |
| Auto-load | On demand when systematic analysis keywords detected |
Enterprise EARS (Evaluate, Analyze, Recommend, Synthesize) Framework expert with AI-powered requirements engineering, Context7 integration, and intelligent solution orchestration for systematic problem-solving.
Revolutionary v4.0.0 capabilities:
Automatic triggers:
Manual invocation:
# AI-powered EARS framework optimization with Context7
class EARSFrameworkOptimizer:
def __init__(self):
self.context7_client = Context7Client()
self.requirements_analyzer = RequirementsAnalyzer()
self.solution_synthesizer = SolutionSynthesizer()
async def apply_ears_framework(self,
problem_context: ProblemContext,
stakeholder_requirements: StakeholderRequirements) -> EARSAnalysis:
"""Apply EARS framework using AI-powered analysis."""
# Get latest requirements engineering and problem-solving documentation via Context7
requirements_docs = await self.context7_client.get_library_docs(
context7_library_id='/requirements-engineering/docs',
topic="stakeholder analysis systematic thinking 2025",
tokens=3000
)
problem_solving_docs = await self.context7_client.get_library_docs(
context7_library_id='/problem-solving/docs',
topic="systematic analysis solution synthesis 2025",
tokens=2000
)
# Phase E: Evaluate
evaluation = await self._evaluate_context(
problem_context,
stakeholder_requirements,
requirements_docs
)
# Phase A: Analyze
analysis = await self._analyze_problem(
problem_context,
evaluation,
problem_solving_docs
)
# Phase R: Recommend
recommendations = await self._recommend_solutions(
analysis,
stakeholder_requirements,
problem_solving_docs
)
# Phase S: Synthesize
synthesis = await self._synthesize_solution(
evaluation,
analysis,
recommendations,
requirements_docs
)
return EARSAnalysis(
evaluation=evaluation,
analysis=analysis,
recommendations=recommendations,
synthesis=synthesis,
confidence_score=self._calculate_confidence_score(evaluation, analysis),
risk_assessment=self._assess_implementation_risks(synthesis)
)
class EvaluationEngine:
async def evaluate_context(self,
problem_context: ProblemContext,
stakeholder_requirements: StakeholderRequirements) -> Evaluation:
"""Comprehensive evaluation of problem context and stakeholders."""
# Stakeholder Analysis
stakeholder_analysis = await self._analyze_stakeholders(
stakeholder_requirements.stakeholders,
problem_context.business_domain
)
# Constraint Evaluation
constraint_analysis = await self._evaluate_constraints(
problem_context.constraints,
problem_context.timeline,
problem_context.budget
)
# Context Assessment
context_assessment = await self._assess_context(
problem_context.business_environment,
problem_context.technical_landscape,
problem_context.organizational_capability
)
return Evaluation(
stakeholder_analysis=stakeholder_analysis,
constraint_analysis=constraint_analysis,
context_assessment=context_assessment,
evaluation_summary=self._create_evaluation_summary(
stakeholder_analysis, constraint_analysis, context_assessment
),
critical_factors=self._identify_critical_factors(
problem_context, stakeholder_requirements
)
)
async def _analyze_stakeholders(self,
stakeholders: List[Stakeholder],
business_domain: str) -> StakeholderAnalysis:
"""Analyze stakeholder requirements and influence."""
stakeholder_matrix = {}
for stakeholder in stakeholders:
# Analyze requirements complexity
complexity_score = self._calculate_requirement_complexity(
stakeholder.requirements
)
# Assess influence and interest
influence_score = self._assess_stakeholder_influence(
stakeholder.role, business_domain
)
interest_score = self._assess_stakeholder_interest(
stakeholder.requirements, stakeholder.motivations
)
# Identify potential conflicts
conflicts = self._identify_requirement_conflicts(
stakeholder.requirements, stakeholders
)
stakeholder_matrix[stakeholder.id] = StakeholderProfile(
stakeholder=stakeholder,
complexity_score=complexity_score,
influence_score=influence_score,
interest_score=interest_score,
conflicts=conflicts,
engagement_strategy=self._determine_engagement_strategy(
influence_score, interest_score
)
)
return StakeholderAnalysis(
stakeholder_matrix=stakeholder_matrix,
stakeholder_map=self._create_stakeholder_map(stakeholder_matrix),
conflict_matrix=self._create_conflict_matrix(stakeholder_matrix),
engagement_plan=self._create_engagement_plan(stakeholder_matrix)
)
class AnalysisEngine:
async def analyze_problem(self,
problem_context: ProblemContext,
evaluation: Evaluation,
problem_solving_docs: Dict) -> Analysis:
"""Deep analysis of problem structure and root causes."""
# Component Breakdown
component_analysis = await self._breakdown_components(
problem_context.problem_statement,
evaluation.context_assessment
)
# Root Cause Analysis
root_cause_analysis = await self._analyze_root_causes(
component_analysis,
problem_context.symptoms,
problem_context.business_impact
)
# Dependency Analysis
dependency_analysis = await self._analyze_dependencies(
component_analysis,
problem_context.technical_landscape,
evaluation.constraint_analysis
)
return Analysis(
component_analysis=component_analysis,
root_cause_analysis=root_cause_analysis,
dependency_analysis=dependency_analysis,
problem_complexity=self._assess_problem_complexity(
component_analysis, root_cause_analysis, dependency_analysis
),
key_insights=self._extract_key_insights(
component_analysis, root_cause_analysis
)
)
async def _analyze_root_causes(self,
component_analysis: ComponentAnalysis,
symptoms: List[Symptom],
business_impact: BusinessImpact) -> RootCauseAnalysis:
"""Perform comprehensive root cause analysis."""
potential_causes = []
for symptom in symptoms:
# Use 5 Whys technique for root cause analysis
root_causes = self._apply_5_whys(symptom)
# Fishbone diagram analysis
fishbone_causes = self._apply_fishbone_analysis(
symptom, component_analysis
)
# Pareto analysis for impact prioritization
pareto_analysis = self._apply_pareto_analysis(
symptom, business_impact
)
potential_causes.append(CauseAnalysis(
symptom=symptom,
root_causes=root_causes,
fishbone_causes=fishbone_causes,
impact_analysis=pareto_analysis,
confidence_score=self._calculate_cause_confidence(
root_causes, fishbone_causes, pareto_analysis
)
))
return RootCauseAnalysis(
cause_analyses=potential_causes,
root_cause_hierarchy=self._create_cause_hierarchy(potential_causes),
impact_matrix=self._create_impact_matrix(potential_causes),
validation_plan=self._create_validation_plan(potential_causes)
)
class RecommendationEngine:
async def recommend_solutions(self,
analysis: Analysis,
stakeholder_requirements: StakeholderRequirements,
problem_solving_docs: Dict) -> Recommendations:
"""Generate and evaluate solution alternatives."""
# Solution Generation
solution_alternatives = await self._generate_solutions(
analysis.root_cause_analysis,
analysis.component_analysis,
analysis.dependency_analysis
)
# Solution Evaluation
solution_evaluation = await self._evaluate_solutions(
solution_alternatives,
stakeholder_requirements,
analysis.constraint_analysis
)
# Risk Assessment
risk_assessment = await self._assess_solution_risks(
solution_evaluation.recommended_solutions,
analysis.dependency_analysis
)
return Recommendations(
solution_alternatives=solution_alternatives,
solution_evaluation=solution_evaluation,
risk_assessment=risk_assessment,
implementation_timeline=self._create_implementation_timeline(
solution_evaluation.recommended_solutions
),
resource_requirements=self._calculate_resource_requirements(
solution_evaluation.recommended_solutions
)
)
async def _generate_solutions(self,
root_cause_analysis: RootCauseAnalysis,
component_analysis: ComponentAnalysis,
dependency_analysis: DependencyAnalysis) -> List[SolutionAlternative]:
"""Generate comprehensive solution alternatives."""
solutions = []
# Solution Pattern 1: Address Root Causes Directly
direct_solutions = self._generate_direct_solutions(root_cause_analysis)
# Solution Pattern 2: System-Level Optimization
system_solutions = self._generate_system_solutions(
component_analysis, dependency_analysis
)
# Solution Pattern 3: Phased Implementation
phased_solutions = self._generate_phased_solutions(
root_cause_analysis, component_analysis
)
# Solution Pattern 4: Technology-Based Solutions
technology_solutions = self._generate_technology_solutions(
component_analysis, dependency_analysis
)
# Solution Pattern 5: Process-Based Solutions
process_solutions = self._generate_process_solutions(
root_cause_analysis, stakeholder_requirements
)
all_solutions = [
*direct_solutions,
*system_solutions,
*phased_solutions,
*technology_solutions,
*process_solutions
]
# Filter and rank solutions
ranked_solutions = self._rank_solutions(all_solutions, root_cause_analysis)
return ranked_solutions[:10] # Return top 10 solutions
class SynthesisEngine:
async def synthesize_solution(self,
evaluation: Evaluation,
analysis: Analysis,
recommendations: Recommendations,
requirements_docs: Dict) -> Synthesis:
"""Synthesize comprehensive solution implementation plan."""
# Solution Integration
integrated_solution = await self._integrate_solutions(
recommendations.recommended_solutions,
analysis.component_analysis
)
# Implementation Planning
implementation_plan = await self._create_implementation_plan(
integrated_solution,
evaluation.constraint_analysis,
recommendations.resource_requirements
)
# Success Metrics Definition
success_metrics = await self._define_success_metrics(
integrated_solution,
evaluation.stakeholder_analysis,
analysis.business_impact
)
# Risk Mitigation Strategy
risk_mitigation = await self._create_risk_mitigation_strategy(
recommendations.risk_assessment,
implementation_plan
)
return Synthesis(
integrated_solution=integrated_solution,
implementation_plan=implementation_plan,
success_metrics=success_metrics,
risk_mitigation=risk_mitigation,
governance_structure=self._define_governance_structure(
evaluation.stakeholder_analysis, implementation_plan
),
validation_criteria=self._create_validation_criteria(
integrated_solution, success_metrics
)
)
async def _create_implementation_plan(self,
integrated_solution: IntegratedSolution,
constraint_analysis: ConstraintAnalysis,
resource_requirements: ResourceRequirements) -> ImplementationPlan:
"""Create detailed implementation plan with phases and milestones."""
# Phase 1: Foundation
foundation_phase = ImplementationPhase(
name="Foundation",
duration="4-6 weeks",
objectives=[
"Establish project governance structure",
"Set up development infrastructure",
"Validate core assumptions",
"Secure stakeholder buy-in"
],
deliverables=[
"Project charter",
"Technical architecture",
"Stakeholder approval",
"Development environment"
],
dependencies=[],
risks=["Stakeholder alignment", "Technical feasibility"]
)
# Phase 2: Core Implementation
core_phase = ImplementationPhase(
name="Core Implementation",
duration="8-12 weeks",
objectives=[
"Implement core solution components",
"Integrate with existing systems",
"Develop necessary tooling",
"Establish monitoring and metrics"
],
deliverables=[
"Core solution implementation",
"System integrations",
"Monitoring dashboard",
"Documentation"
],
dependencies=[foundation_phase],
risks=["Technical complexity", "Integration challenges"]
)
# Phase 3: Optimization
optimization_phase = ImplementationPhase(
name="Optimization",
duration="4-8 weeks",
objectives=[
"Optimize solution performance",
"Scale to full operation",
"Train stakeholders",
"Establish operational procedures"
],
deliverables=[
"Optimized solution",
"Training materials",
"Operational procedures",
"Performance reports"
],
dependencies=[core_phase],
risks=["Performance issues", "User adoption"]
)
return ImplementationPlan(
phases=[foundation_phase, core_phase, optimization_phase],
timeline=self._create_detailed_timeline(
[foundation_phase, core_phase, optimization_phase]
),
resource_allocation=resource_requirements,
governance_structure=self._define_phase_governance(),
quality_gates=self._define_quality_gates()
)
evaluate_context(problem_context, stakeholders) - Evaluate problem contextanalyze_problem(evaluation, symptoms) - Analyze problem structurerecommend_solutions(analysis, constraints) - Generate solution recommendationssynthesize_solution(evaluation, analysis, recommendations) - Synthesize final solutionvalidate_implementation(synthesis, metrics) - Validate implementation approachget_latest_requirements_docs() - Requirements engineering via Context7analyze_systematic_thinking_patterns() - Problem-solving methodologies via Context7optimize_solution_synthesis() - Solution optimization via Context7moai-foundation-specs (SPEC lifecycle management)moai-alfred-spec-authoring (SPEC creation and writing)moai-foundation-trust (Trust and quality principles)moai-domain-backend (Technical solution implementation)moai-security-api (Security requirements analysis)moai-essentials-perf (Performance requirements)moai-domain-devops (Implementation planning)moai-foundation-git (Version control and collaboration)End of Skill | Updated 2025-11-13
End of Enterprise EARS Framework Expert v4.0.0