intelligence-analysis-techniques

# Intelligence Analysis Techniques Skill ## Purpose This skill provides comprehensive structured analytic techniques (SATs) for intelligence analysis in the CIA platform. It implements proven methodologies from the intelligence community to reduce cognitive bias, improve analytical rigor, and produce defensible intelligence assessments on Swedish political actors, parties, and democratic institutions. ## When to Use This Skill Apply this skill when: - ✅ Analyzing complex political situations with multiple competing hypotheses - ✅ Assessing coalition formation scenarios and government stability - ✅ Evaluating politician behavior patterns and risk indicators - ✅ Conducting strategic assessments of party positions - ✅ Identifying analytical assumptions and challenging conventional wisdom - ✅ Preparing high-confidence intelligence products for stakeholders - ✅ Mitigating cognitive biases in analysis (confirmation bias, anchoring) Do NOT use for: - ❌ Simple data aggregation or reporting (use query tools instead) - ❌ Real-time operational decisions (SATs require deliberate analysis) - ❌ Situations requiring immediate answers without time for structured analysis ## Structured Analytic Techniques Framework ### CIA Platform Analytics Categories ```mermaid graph TB subgraph "Data Foundation" A[OSINT Collection] --> B[Data Integration] B --> C[Quality Validation] end subgraph "Structured Analytic Techniques" C --> D["Decomposition & Visualization"] C --> E[Idea Generation] C --> F["Hypothesis Generation & Testing"] C --> G["Scenarios & Indicators"] C --> H[Challenge Analysis] end subgraph "Technique Categories" D --> D1[Key Assumptions Check] D --> D2[Issue Redefinition] E --> E1[Brainstorming] E --> E2[Red Team Analysis] F --> F1[Analysis of Competing Hypotheses] F --> F2[Diagnostic Reasoning] G --> G1[Alternative Futures] G --> G2[Indicators Development] H --> H1[Devil's Advocacy] H --> H2[Team A/Team B] end subgraph "Intelligence Products" D1 & D2 & E1 & E2 & F1 & F2 & G1 & G2 & H1 & H2 --> I[Risk Assessments] I --> J[Political Scorecards] I --> K[Coalition Analysis] I --> L[Trend Reports] end style A fill:#e1f5ff style F1 fill:#ffeb99 style H1 fill:#ffcccc style I fill:#ccffcc ``` ## 1. Analysis of Competing Hypotheses (ACH) **Purpose:** Systematically evaluate multiple explanations to reduce confirmation bias and identify the most likely scenario. **When to Use:** - Coalition formation predictions - Politician defection risk assessment - Party strategy interpretation - Policy position shifts **CIA Platform Application:** ### Example: Coalition Formation After 2022 Election **Question:** Which coalition is most likely to form the government? **Hypotheses:** ``` H1: Center-right coalition (M, KD, SD, L) - 176 seats H2: Center-right minority (M, KD, L) with SD support - 116 + 73 external H3: Center-left coalition (S, V, MP, C) - 159 seats (minority) H4: Grand coalition (S, M, C) - 159 seats H5: Sweden Democrats lead coalition (SD, M, KD) - 141 seats ``` **Evidence Matrix:** ```sql -- Generate ACH Evidence Matrix from voting patterns and party statements WITH party_alignment AS ( SELECT p1.party as party_a, p2.party as party_b, COUNT(CASE WHEN p1.vote = p2.vote THEN 1 END) as agreement_votes, COUNT(*) as total_votes, ROUND(100.0 * COUNT(CASE WHEN p1.vote = p2.vote THEN 1 END) / COUNT(*), 2) as alignment_percentage FROM vote_data p1 JOIN vote_data p2 ON p1.ballot_id = p2.ballot_id AND p1.party < p2.party WHERE p1.vote_date >= '2022-09-11' -- Current parliament AND p1.vote IN ('Ja', 'Nej') AND p2.vote IN ('Ja', 'Nej') GROUP BY p1.party, p2.party ) SELECT * FROM party_alignment WHERE alignment_percentage > 70 -- Strong alignment threshold ORDER BY alignment_percentage DESC; ``` **ACH Implementation:** ```java @Service public class CompetingHypothesesAnalyzer { public ACHResult analyzeCoalitionFormation(List<Hypothesis> hypotheses, List<Evidence> evidence) { // 1. Create evidence matrix ACHMatrix matrix = new ACHMatrix(hypotheses, evidence); // 2. Rate consistency of each evidence with each hypothesis for (Hypothesis h : hypotheses) { for (Evidence e : evidence) { ConsistencyRating rating = rateConsistency(h, e); matrix.setCell(h, e, rating); } } // 3. Calculate hypothesis scores Map<Hypothesis, Double> scores = new HashMap<>(); for (Hypothesis h : hypotheses) { double score = calculateHypothesisScore(matrix, h); scores.put(h, score); } // 4. Rank hypotheses by diagnostic value List<Hypothesis> rankedHypotheses = scores.entrySet().stream() .sorted(Map.Entry.<Hypothesis, Double>comparingByValue().reversed()) .map(Map.Entry::getKey) .collect(Collectors.toList()); // 5. Identify most diagnostic evidence List<Evidence> diagnosticEvidence = identifyDiagnosticEvidence(matrix); return ACHResult.builder() .matrix(matrix) .rankedHypotheses(rankedHypotheses) .diagnosticEvidence(diagnosticEvidence) .confidence(calculateConfidence(scores)) .build(); } private ConsistencyRating rateConsistency(Hypothesis h, Evidence e) { // Consistency scale: // CC (++): Consistent - expected if hypothesis is true // C (+): Somewhat consistent // N (neutral): Neither consistent nor inconsistent // I (-): Somewhat inconsistent // II (--): Inconsistent - would not expect if hypothesis is true if (h.getName().equals("Center-right coalition") && e.getType().equals("VOTING_ALIGNMENT") && e.getParties().containsAll(Arrays.asList("M", "KD", "L"))) { return ConsistencyRating.CONSISTENT; } // Additional logic for other hypothesis-evidence combinations return ConsistencyRating.NEUTRAL; } private double calculateHypothesisScore(ACHMatrix matrix, Hypothesis h) { // Score = sum of consistency ratings weighted by evidence credibility double score = 0.0; for (Evidence e : matrix.getEvidence()) { ConsistencyRating rating = matrix.getCell(h, e); score += rating.getValue() * e.getCredibility(); } return score; } } ``` **ACH Output Example:** | Evidence | H1 | H2 | H3 | H4 | H5 | |----------|----|----|----|----|-----| | M-KD-L voting alignment >80% | ++ | ++ | -- | + | + | | SD explicitly supports M-led govt | ++ | ++ | -- | -- | + | | S refuses SD cooperation | -- | -- | + | N | -- | | C rejects left-wing coalition | ++ | ++ | -- | + | -- | | L historically opposed SD | N | + | N | N | -- | | Parliamentary math (176 seats) | ++ | + | -- | N | -- | | **TOTAL SCORE** | **+9** | **+7** | **-8** | **0** | **-4** | **Conclusion:** H1 (Center-right coalition with SD) most consistent with evidence. Confidence: HIGH (80%). ## 2. SWOT Analysis **Purpose:** Systematically assess Strengths, Weaknesses, Opportunities, and Threats for strategic planning. **CIA Platform Application:** ### Example: Party Strategic Assessment - Social Democrats (S) ```sql -- Generate SWOT data from CIA platform views WITH party_metrics AS ( SELECT party, AVG(total_days_served) as avg_experience_days, AVG(percent_yes + percent_no) as avg_participation_rate, COUNT(DISTINCT person_id) as party_size FROM view_riksdagen_politician_summary WHERE party = 'S' GROUP BY party ), party_performance AS ( SELECT party, AVG(percentage_won) as win_rate, COUNT(DISTINCT ballot_id) as ballots_participated FROM view_riksdagen_party_ballot_support_annual_summary WHERE party = 'S' AND election_year >= EXTRACT(YEAR FROM CURRENT_DATE) - 4 GROUP BY party ), coalition_potential AS ( SELECT 'S' as party, SUM(parliament_seats) as potential_coalition_seats FROM sweden_political_party WHERE party_name IN ('S', 'V', 'MP', 'C') ) SELECT pm.*, pp.win_rate, pp.ballots_participated, cp.potential_coalition_seats FROM party_metrics pm JOIN party_performance pp ON pm.party = pp.party CROSS JOIN coalition_potential cp; ``` **SWOT Matrix Implementation:** ```java @Service public class SWOTAnalyzer { public SWOTAnalysis performPartySWOT(String partyCode) { // Strengths: Internal positive factors List<String> strengths = new ArrayList<>(); // Query: Check party size and parliamentary seats Integer seats = partyRepository.getParliamentSeats(partyCode); if (seats != null && seats > 50) { strengths.add("Large parliamentary representation (" + seats + " seats)"); } // Query: Check government experience Long governmentDays = partyRepository.getTotalGovernmentDays(partyCode); if (governmentDays > 3650) { // 10+ years strengths.add("Extensive government experience (" + (governmentDays / 365) + " years)"); } // Query: Check voting discipline Double discipline = partyRepository.getVotingDiscipline(partyCode); if (discipline > 95.0) { strengths.add("High party discipline (" + discipline + "%)"); } // Weaknesses: Internal negative factors List<String> weaknesses = new ArrayList<>(); // Query: Check declining support Double supportTrend = partyRepository.getSupportTrend(partyCode, 4); // Last 4 years if (supportTrend < -2.0) { weaknesses.add("Declining electoral support (" + supportTrend + "% over 4 years)"); } // Query: Check internal conflicts (defections) Long defections = partyRepository.getDefectionCount(partyCode, 4); if (defections > 2) { weaknesses.add("Internal instability (" + defections + " defections in 4 years)"); } // Opportunities: External positive factors List<String> opportunities = new ArrayList<>(); // Query: Coalition potential Integer potentialCoalitionSeats = partyRepository.getCoalitionSeats(partyCode); if (potentialCoalitionSeats > 175) { opportunities.add("Viable coalition path to majority (" + potentialCoalitionSeats + " seats)"); } // Query: Issue ownership List<String> ownedIssues = partyRepository.getDominantPolicyAreas(partyCode); opportunities.add("Issue ownership in: " + String.join(", ", ownedIssues)); // Threats: External negative factors List<String> threats = new ArrayList<>(); // Query: Competitor strength Double competitorStrength = partyRepository.getLargestCompetitorStrength(partyCode); if (competitorStrength > 25.0) { threats.add("Strong competitor party (" + competitorStrength + "% support)"); } // Query: Coalition instability Double coalitionAlignment = partyRepository.getCoalitionAlignment(partyCode); if (coalitionAlignment < 80.0) { threats.add("Coalition alignment challenges (" + coalitionAlignment + "%)"); } return SWOTAnalysis.builder() .partyCode(partyCode) .strengths(strengths) .weaknesses(weaknesses) .opportunities(opportunities) .threats(threats) .build(); } } ``` **SWOT Output Example:** ``` ═════════════════════════════════════════════════════════════ SWOT ANALYSIS: Social Democrats (S) ═════════════════════════════════════════════════════════════ STRENGTHS (Internal Positive) ───────────────────────────────────────────────────────────── ✅ Largest parliamentary party (107 seats, 30.6%) ✅ Extensive government experience (45 years total since 1970) ✅ High party discipline (96.3% voting cohesion) ✅ Strong union relationships and funding base ✅ Broad geographic support across all regions WEAKNESSES (Internal Negative) ───────────────────────────────────────────────────────────── ❌ Declining electoral support (-3.2% since 2018) ❌ Leadership transition challenges ❌ Weak position on immigration issue (dominated by SD) ❌ Aging voter base (median age 58) OPPORTUNITIES (External Positive) ───────────────────────────────────────────────────────────── 🔵 Coalition potential with V, MP, C = 159 seats (near majority) 🔵 Economic downturn favors welfare focus 🔵 Environmental policy increasingly salient 🔵 Potential to reclaim centrist voters from M THREATS (External Negative) ───────────────────────────────────────────────────────────── 🔴 SD growth (20.5% in 2022, +3.1% from 2018) 🔴 Center-right coalition controls 176 seats 🔴 Fragmented left bloc (S, V, MP divergent priorities) 🔴 Policy space squeezed between left (V) and center (C) ═════════════════════════════════════════════════════════════ ``` ## 3. Devil's Advocacy **Purpose:** Challenge prevailing assumptions by deliberately arguing against consensus position. **CIA Platform Application:** ### Example: Challenging Assumption of Coalition Stability **Prevailing View:** "The center-right government is stable with 176 seats." **Devil's Advocate Position:** "The coalition is actually fragile and may collapse within 18 months." **Challenging Arguments:** ```java @Service public class DevilsAdvocacyAnalyzer { public ChallengeAnalysis challengeCoalitionStability(String coalitionName) { ChallengeAnalysis analysis = new ChallengeAnalysis(); analysis.setPrevailingView("Coalition is stable"); analysis.setChallengePosition("Coalition is fragile"); // 1. Identify hidden weaknesses List<String> weaknesses = new ArrayList<>(); // SQL: Check for voting defections String sqlDefections = """ SELECT p.party, COUNT(CASE WHEN v.vote != modal_vote.mode THEN 1 END) as defection_count, COUNT(*) as total_votes, ROUND(100.0 * COUNT(CASE WHEN v.vote != modal_vote.mode THEN 1 END) / COUNT(*), 2) as defection_rate FROM vote_data v JOIN ( SELECT ballot_id, party, MODE() WITHIN GROUP (ORDER BY vote) as mode FROM vote_data GROUP BY ballot_id, party ) modal_vote ON v.ballot_id = modal_vote.ballot_id AND v.party = modal_vote.party WHERE v.party IN ('M', 'KD', 'L') AND v.vote_date >= CURRENT_DATE - INTERVAL '6 months' GROUP BY p.party HAVING ROUND(100.0 * COUNT(CASE WHEN v.vote != modal_vote.mode THEN 1 END) / COUNT(*), 2) > 5.0 """; List<PartyDisciplineMetric> defections = jdbcTemplate.query(sqlDefections, (rs, rowNum) -> new PartyDisciplineMetric( rs.getString("party"),