Skip to main content Skills Marketplace Découvrez et explorez les compétences IA créées par la communauté.
Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Afficher les détails du prompt Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
npx skills add https://github.com/AJBcoding/claude-skill-eval --skill moai-foundation-earsLa commande reste sur une seule ligne. Faites défiler horizontalement pour la vérifier avant de la copier.
Vous préférez une copie locale ? Téléchargez les fichiers actuellement disponibles dans SkillsMP.
Télécharger Zip Téléchargement... Plus depuis ce dépôt 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).
Métiers associés SOC
Basé sur la classification professionnelle SOC
Explorateur de fichiers
3 fichiers 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"]
Enterprise EARS Framework Expert v4.0.0
Skill Metadata
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
What It Does
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 :
🤖 AI-Powered EARS Analysis using Context7 MCP for latest problem-solving methodologies
📊 Intelligent Requirements Engineering with automated stakeholder analysis and validation
🚀 Advanced Solution Synthesis with AI-driven alternative evaluation and optimization
🔗 Enterprise Decision Framework with zero-configuration systematic thinking processes
📈 Predictive Solution Validation with success probability and risk assessment
When to Use
Automatic triggers :
Complex problem analysis and systematic solution design discussions
Requirements engineering and stakeholder alignment processes
Decision-making framework implementation and evaluation
Project planning and solution architecture validation
Manual invocation :
Applying EARS framework to complex business problems
Conducting systematic requirements analysis and validation
Designing solution alternatives with comprehensive evaluation
Implementing structured decision-making processes
Quick Reference (Level 1)
EARS Framework Overview
Four-Phase Systematic Analysis
E - Evaluate : Assess problem context, stakeholders, constraintsA - Analyze : Break down components, identify root causes, examine dependencies
R - Recommend : Generate solutions, evaluate alternatives, provide recommendations
S - Synthesize : Integrate solutions, create implementation plan, validate approach
Core Principles
Systematic Thinking : Structured approach to complex problemsStakeholder-Centric : Focus on user and business requirementsEvidence-Based : Data-driven analysis and decision makingIterative Refinement : Continuous improvement and validation
Application Areas
Requirements Engineering : Systematic requirement gathering and validationSolution Architecture : Comprehensive solution design and evaluationProject Planning : Structured project analysis and planningRisk Management : Systematic risk identification and mitigation
Integration Benefits
Consistency : Standardized approach across projectsQuality : Thorough analysis reduces oversight and errorsCollaboration : Clear framework for team alignmentDocumentation : Systematic record of analysis and decisions
Core Implementation (Level 2)
EARS Architecture Intelligence
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."""
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
)
evaluation = await self ._evaluate_context(
problem_context,
stakeholder_requirements,
requirements_docs
)
analysis = await self ._analyze_problem(
problem_context,
evaluation,
problem_solving_docs
)
recommendations = await self ._recommend_solutions(
analysis,
stakeholder_requirements,
problem_solving_docs
)
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)
)
Phase E: Evaluation Implementation class EvaluationEngine :
async def evaluate_context (self,
problem_context: ProblemContext,
stakeholder_requirements: StakeholderRequirements ) -> Evaluation:
"""Comprehensive evaluation of problem context and stakeholders."""
stakeholder_analysis = await self ._analyze_stakeholders(
stakeholder_requirements.stakeholders,
problem_context.business_domain
)
constraint_analysis = await self ._evaluate_constraints(
problem_context.constraints,
problem_context.timeline,
problem_context.budget
)
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:
complexity_score = self ._calculate_requirement_complexity(
stakeholder.requirements
)
influence_score = self ._assess_stakeholder_influence(
stakeholder.role, business_domain
)
interest_score = self ._assess_stakeholder_interest(
stakeholder.requirements, stakeholder.motivations
)
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)
)
Phase A: Analysis Implementation 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_analysis = await self ._breakdown_components(
problem_context.problem_statement,
evaluation.context_assessment
)
root_cause_analysis = await self ._analyze_root_causes(
component_analysis,
problem_context.symptoms,
problem_context.business_impact
)
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:
root_causes = self ._apply_5_whys(symptom)
fishbone_causes = self ._apply_fishbone_analysis(
symptom, component_analysis
)
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)
)
Advanced Implementation (Level 3)
Phase R: Recommendations Implementation class RecommendationEngine :
async def recommend_solutions (self,
analysis: Analysis,
stakeholder_requirements: StakeholderRequirements,
problem_solving_docs: Dict ) -> Recommendations:
"""Generate and evaluate solution alternatives."""
solution_alternatives = await self ._generate_solutions(
analysis.root_cause_analysis,
analysis.component_analysis,
analysis.dependency_analysis
)
solution_evaluation = await self ._evaluate_solutions(
solution_alternatives,
stakeholder_requirements,
analysis.constraint_analysis
)
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 = []
direct_solutions = self ._generate_direct_solutions(root_cause_analysis)
system_solutions = self ._generate_system_solutions(
component_analysis, dependency_analysis
)
phased_solutions = self ._generate_phased_solutions(
root_cause_analysis, component_analysis
)
technology_solutions = self ._generate_technology_solutions(
component_analysis, dependency_analysis
)
process_solutions = self ._generate_process_solutions(
root_cause_analysis, stakeholder_requirements
)
all_solutions = [
*direct_solutions,
*system_solutions,
*phased_solutions,
*technology_solutions,
*process_solutions
]
ranked_solutions = self ._rank_solutions(all_solutions, root_cause_analysis)
return ranked_solutions[:10 ]
Phase S: Synthesis Implementation class SynthesisEngine :
async def synthesize_solution (self,
evaluation: Evaluation,
analysis: Analysis,
recommendations: Recommendations,
requirements_docs: Dict ) -> Synthesis:
"""Synthesize comprehensive solution implementation plan."""
integrated_solution = await self ._integrate_solutions(
recommendations.recommended_solutions,
analysis.component_analysis
)
implementation_plan = await self ._create_implementation_plan(
integrated_solution,
evaluation.constraint_analysis,
recommendations.resource_requirements
)
success_metrics = await self ._define_success_metrics(
integrated_solution,
evaluation.stakeholder_analysis,
analysis.business_impact
)
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."""
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" ]
)
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" ]
)
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()
)
Reference & Integration (Level 4)
API Reference
Core EARS Operations
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 approach
Context7 Integration
get_latest_requirements_docs() - Requirements engineering via Context7analyze_systematic_thinking_patterns() - Problem-solving methodologies via Context7optimize_solution_synthesis() - Solution optimization via Context7
Best Practices (November 2025)
DO
Follow the EARS framework systematically for complex problems
Involve all relevant stakeholders throughout the process
Use data-driven analysis for objective decision making
Document all assumptions, constraints, and decisions
Validate solutions with stakeholders before implementation
Consider multiple solution alternatives and approaches
Plan for risks and develop mitigation strategies
Establish clear success metrics and validation criteria
DON'T
Skip phases or rush through the systematic analysis
Ignore stakeholder requirements and concerns
Rely on assumptions without data validation
Overlook constraint analysis and resource limitations
Forget to document the analysis and decision process
Implement solutions without proper validation
Neglect risk assessment and mitigation planning
Skip success metrics definition and monitoring
Works Well With
moai-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)
Changelog
v4.0.0 (2025-11-13): Complete Enterprise v4.0 rewrite with 40% content reduction, 4-layer Progressive Disclosure structure, Context7 integration, advanced systematic thinking patterns, and comprehensive solution synthesisv2.0.0 (2025-11-11): Complete metadata structure, EARS framework patterns, stakeholder analysisv1.0.0 (2025-11-11): Initial EARS framework foundation
End of Skill | Updated 2025-11-13
Framework Integration
EARS Integration Patterns
Seamless integration with SPEC lifecycle management
Stakeholder analysis integration with project governance
Solution synthesis integration with development workflows
Risk assessment integration with quality gates
Enterprise Adoption
Standardized problem-solving methodology across teams
Consistent documentation and decision-making processes
Integration with existing project management tools
Training and adoption support for organizations
End of Enterprise EARS Framework Expert v4.0.0
