@xonovex/skills 0.1.0

package/skills/strudel-guidelines/SKILL.md

@@ -0,0 +1,52 @@
+---
+name: strudel-guidelines
+description: >-
+  Trigger on Strudel music generation, `.strudel` files, live coding music tasks. Use when generating algorithmic music with Strudel.cc. Apply for pattern composition, effects processing, genre-specific production, browser-based live coding. Keywords: Strudel, TidalCycles, live coding, algorithmic music, mini-notation, patterns, electronic music, trance, ambient, techno.
+---
+
+# Strudel Music Coding Guidelines
+
+## Requirements
+
+- Browser with https://strudel.cc/ (no installation needed)
+- Copy-paste code, Ctrl+Enter to play, Ctrl+. to stop
+
+## Essentials
+
+- **Tempo** - Set BPM first with `setcpm(BPM/4)`, see [reference/tempo-timing.md](reference/tempo-timing.md)
+- **Mini-notation** - Space-separated sequences, `*` multiply, `/` divide, `<>` alternate, `[]` subdivide, `~` rest, see [reference/mini-notation.md](reference/mini-notation.md)
+- **Layering** - Use `stack()` to combine patterns, each layer independent, see [reference/layering.md](reference/layering.md)
+- **Sounds** - Drums: `bd`, `sd`, `hh`, `oh`, `cp`; Synths: `sine`, `sawtooth`, `square`, `triangle`, see [reference/sounds.md](reference/sounds.md)
+- **Effects** - `.gain()`, `.lpf()`, `.room()`, `.delay()`, `.shape()`, `.crush()`, see [reference/effects.md](reference/effects.md)
+- **Modulation** - `sine.range(a,b).slow(n)` for sweeps, `perlin` for organic variation, see [reference/modulation.md](reference/modulation.md)
+- **Conditional** - `.every(n, fn)`, `.sometimes(fn)`, `.degradeBy(p)` for variation, see [reference/conditionals.md](reference/conditionals.md)
+- **Structure** - Use `.mask()` for sections, `arrange()` for song form, see [reference/arrangement.md](reference/arrangement.md)
+
+## Example
+
+```javascript
+setcpm(138/4)
+
+stack(
+  s("bd*4").gain(0.8),
+  s("~ cp ~ cp").gain(0.5).room(0.3),
+  s("hh*16").gain(0.3).lpf(sine.range(800, 4000).slow(4)),
+  note("a2*8").sound("sawtooth").lpf(700).gain(0.5),
+  note("<a3 f3 c4 g3>").sound("sawtooth").lpf(2000).room(0.8).gain(0.3)
+)
+```
+
+## Progressive Disclosure
+
+- Read [reference/mini-notation.md](reference/mini-notation.md) - When learning pattern syntax or fixing notation errors
+- Read [reference/sounds.md](reference/sounds.md) - When selecting instruments or troubleshooting missing sounds
+- Read [reference/effects.md](reference/effects.md) - When applying audio processing or creating textures
+- Read [reference/modulation.md](reference/modulation.md) - When adding movement and dynamic variation
+- Read [reference/conditionals.md](reference/conditionals.md) - When creating algorithmic variation
+- Read [reference/layering.md](reference/layering.md) - When combining multiple patterns
+- Read [reference/tempo-timing.md](reference/tempo-timing.md) - When setting tempo or working with time
+- Read [reference/arrangement.md](reference/arrangement.md) - When structuring full compositions
+- Read [reference/genre-trance.md](reference/genre-trance.md) - When producing uplifting/hard trance
+- Read [reference/genre-ambient.md](reference/genre-ambient.md) - When creating atmospheric soundscapes
+- Read [reference/genre-harsh.md](reference/genre-harsh.md) - When making experimental/industrial music
+- Read [reference/scales-harmony.md](reference/scales-harmony.md) - When working with melodies and chords

package/skills/strudel-guidelines/reference/arrangement.md

@@ -0,0 +1,24 @@
+# arrangement: Song Structure and Arrangement
+
+**Guideline:** Organize compositions into distinct sections using `.mask()` and `arrange()` to build tension, peaks, and release.
+
+**Rationale:** Structured arrangements create emotional arcs; static loops lack engagement and dynamics.
+
+**Example:**
+```javascript
+arrange(
+  [4, intro],     // 4 cycles
+  [4, buildup],   // Building tension
+  [8, drop],      // Climax
+  [4, breakdown], // Release
+  [8, drop]       // Return
+)
+```
+
+**Techniques:**
+- `.mask("1 1 0 0 0 0 0 0")`: Play first half of 8-subdivision cycle
+- `arrange([cycles, pattern], ...)`: Sequence sections with precise lengths
+- `.every(n, x => x.fast(2))`: Accelerate rhythms to build intensity
+- Layer stacking: Add/remove instruments progressively for tension
+- Filter sweeps: Use `saw.range(200, 3000).slow(16)` for gradual builds
+- Classic EDM: intro→buildup→drop→breakdown→buildup→drop→outro

package/skills/strudel-guidelines/reference/conditionals.md

@@ -0,0 +1,22 @@
+# conditionals: Conditional and Probabilistic Transformations
+
+**Guideline:** Use `.every(n, fn)`, probability functions, and `.degradeBy()` to add algorithmic variation without manual editing.
+
+**Rationale:** Procedural variation creates organic, evolving patterns; manual static edits sound lifeless and repetitive.
+
+**Example:**
+```javascript
+// Evolving drum pattern
+s("bd*4")
+  .every(4, x => x.fast(2))     // Double speed every 4 cycles
+  .every(8, x => x.gain(0.5))   // Quieter every 8 cycles
+  .sometimes(x => x.speed(0.5)) // Occasional pitch drop
+```
+
+**Techniques:**
+- `.every(n, fn)`: Apply transformation periodically (repeats every n cycles)
+- `.sometimes()`, `.often()`, `.rarely()`, `.almostAlways()`: Probabilistic 50%, 75%, 10%, 90%
+- `.degradeBy(0.7)`: Keep only 70% of events (sparse/glitchy feel)
+- `.jux(fn)`: Apply to right channel only (stereo width effect)
+- `.stut(4, 0.5, 1/16)`: Echo/stutter with decay
+- `.scramble()`, `.shuffle()`: Randomize event order or rotate subdivisions

package/skills/strudel-guidelines/reference/effects.md

@@ -0,0 +1,22 @@
+# effects: Audio Effects and Processing
+
+**Guideline:** Chain effects with dot notation; balance gain staging, use filters for EQ, and add space with reverb/delay.
+
+**Rationale:** Tasteful effects shape tone and add movement; poor gain staging causes clipping or loss of clarity.
+
+**Example:**
+```javascript
+// Acid bass
+note("c2*8").sound("sawtooth")
+  .lpf(sine.range(300, 1500).slow(4))  // Sweep filter
+  .lpq(12)        // High resonance
+  .gain(0.5)
+```
+
+**Techniques:**
+- Gain staging: kick 0.7-0.85, bass 0.5-0.6, leads 0.4-0.6, hats 0.2-0.35
+- `.lpf(cutoff)`, `.hpf(cutoff)`: Shape frequency space (sub-bass 40-100Hz, muddy 300-600Hz)
+- `.lpq(resonance)`: Add peak at filter cutoff for acid sweeps
+- `.room(0.5)`, `.delay(0.3)`: Create space without muddying mix
+- `.shape(0.3)`, `.crush(8)`: Distortion and bit-reduction for texture
+- `.attack(0.1).sustain(0.5).release(0.3)`: Control envelope shape

package/skills/strudel-guidelines/reference/genre-ambient.md

@@ -0,0 +1,26 @@
+# genre-ambient: Ambient and Atmospheric Music
+
+**Guideline:** Create atmospheric soundscapes with slow tempos, sparse elements, heavy reverb, and gradual evolution.
+
+**Rationale:** Ambient music relies on slow pacing, delayed effects, and minimal change to create meditative, immersive atmospheres.
+
+**Example:**
+
+```javascript
+setcpm(70/4)  // 70 BPM
+
+stack(
+  note("c2").sound("sine").attack(3).sustain(8).release(4).room(0.9).gain(0.25).slow(8),
+  note("<c4 eb4 g4 bb4>").sound("triangle").attack(1).sustain(2).release(2)
+    .room(0.85).lpf(perlin.range(500, 2000).slow(8)).gain(0.2).slow(2),
+  note("g5 ~ ~ ~ ~ eb5 ~ ~").sound("sine").room(0.9).delay(0.6).delayfeedback(0.7).gain(0.2).degradeBy(0.4),
+  s("white").lpf(perlin.range(300, 800).slow(16)).gain(0.08)
+)
+```
+
+**Techniques:**
+- Slow tempo (60-90 BPM): Use `setcpm(70/4)` for 70 BPM
+- Heavy reverb: `.room(0.85-0.95)` for spatial depth
+- Sparse elements: `.degradeBy(0.3-0.5)` to drop notes randomly
+- Long envelopes: `.attack(2-4)` and `.release(3-4)` for gradual transitions
+- Layered drones: Stack multiple sine/triangle notes at different octaves with `.slow()` modulation

package/skills/strudel-guidelines/reference/genre-harsh.md

@@ -0,0 +1,21 @@
+# filename: genre-harsh
+
+**Guideline:** Create harsh, experimental textures using extreme distortion, bit crushing, noise, and chaotic polyrhythms for intentional sonic destruction.
+
+**Rationale:** Harsh music demands intentional degradation and dissonance; extreme effect values and dark scales create cohesive experimental aesthetics.
+
+**Example:**
+```javascript
+stack(
+  s("bd(7,8)").gain(0.9).crush(5).shape(0.4),
+  note("[-12 -11 -10]*32").scale("A2:locrian").sound("sawtooth")
+    .lpf(perlin.range(400, 2000)).crush(5).shape(0.6).gain(0.5)
+)
+```
+
+**Techniques:**
+- Extreme effects: `.crush(2-4)`, `.coarse(32-64)`, `.shape(0.8-2)` for maximum harshness
+- Noise layers: `s("white")` with `.hpf()`, `.bpf()`, `.degradeBy()` for texture
+- Dissonant scales: Locrian, Phrygian, chromatic clusters for dark tonality
+- Glitch methods: `.degradeBy(0.7)`, `.scramble()`, `.stut(8, 0.5)` for chaos
+- Polyrhythms: Competing time signatures `.bd(7,8)`, `.sd(5,8)`, `.hh(11,16)` for instability

package/skills/strudel-guidelines/reference/genre-trance.md

@@ -0,0 +1,23 @@
+# filename: genre-trance
+
+**Guideline:** Build uplifting trance with four-on-the-floor kicks, rolling basslines, euphoric melodies, and filter sweeps at 138-145 BPM.
+
+**Rationale:** Trance requires precise tempo, layered elements, and evolving filters; proper gain hierarchy and chord progressions maintain energy and emotional impact.
+
+**Example:**
+```javascript
+setcpm(138/4)
+stack(
+  s("bd*4").gain(0.85).lpf(150),
+  note("<a2 a2 f2 g2>*4").sound("sawtooth")
+    .lpf(sine.range(400, 1200).slow(4)).gain(0.52),
+  s("hh*16").gain(0.28).hpf(6000)
+)
+```
+
+**Techniques:**
+- Tempo: `setcpm(138-145/4)` for classic to hard trance pacing
+- Four-on-the-floor: `s("bd*4")` with punchy filtering `.lpf(150)`
+- Rolling bass: `note("*8" or "*16")` with filter automation `.lpf(sine.range())`
+- Filter sweeps: `.lpf(saw.range(200, 2000).slow(16))` for build tension
+- Gain hierarchy: Kick 0.85, Bass 0.52, Lead 0.42, Pads 0.28, Hats 0.28

package/skills/strudel-guidelines/reference/layering.md

@@ -0,0 +1,22 @@
+# filename: layering
+
+**Guideline:** Use `stack()` to combine independent patterns organized by role (rhythm, bass, harmony, melody) with balanced gain levels.
+
+**Rationale:** Clear layer hierarchy prevents overlap and mud; role-based organization enables independent editing and coherent mixes.
+
+**Example:**
+```javascript
+stack(
+  s("bd*4").gain(0.8).lpf(150),
+  note("c2*8").sound("sawtooth").lpf(600).gain(0.5),
+  note("c5 e5 g5 e5").sound("sawtooth").lpf(3000).gain(0.4),
+  s("hh*16").gain(0.25).hpf(6000)
+)
+```
+
+**Techniques:**
+- Layer hierarchy: Kick 0.8-0.9, Bass 0.5-0.6, Lead 0.4-0.5, Pads 0.2-0.4, Hats 0.2-0.4
+- Multi-layer drums: `.late(0.01)` and `.late(0.02)` offsets for depth
+- Role organization: Rhythm → Bass → Harmony → Melody → Texture in stack order
+- Variable patterns: Define as `const layer = pattern` for clarity and reusability
+- Combination functions: `stack()` simultaneous, `cat()` sequential per cycle, `arrange()` explicit counts

package/skills/strudel-guidelines/reference/mini-notation.md

@@ -0,0 +1,74 @@
+# mini-notation: Pattern Mini-Notation Syntax
+
+**Guideline:** Use Strudel mini-notation operators to express rhythmic and melodic patterns concisely.
+
+**Rationale:** Mini-notation provides compact syntax for complex structures without verbose function calls.
+
+**Example:**
+
+```javascript
+// Simple drum pattern
+s("bd sd ~ sd")  // Kick, snare, rest, snare
+
+// Repeat with multiply
+s("bd*4 hh*8")   // 4 kicks, 8 hi-hats in one cycle
+
+// Subdivisions
+s("[bd sd] [hh hh]")  // Two groups fitted in one step each
+
+// Euclidean rhythm (3 hits over 8 steps)
+s("bd(3,8)")
+
+// Parallel layers
+s("bd*4, hh*16")  // Kick layer + hi-hat layer simultaneously
+
+// Chord progression
+note("<c3 e3 g3 b3>")  // One note per cycle (ascending pattern)
+```
+
+## Core Operators
+
+| Operator | Syntax | Description |
+|----------|--------|-------------|
+| Space | `a b c` | Sequential |
+| Rest | `~` | Silence |
+| Multiply | `a*4` | Repeat 4x |
+| Divide | `a/2` | Stretch over 2 cycles |
+| Subdivide | `[a b]` | Fit both in one step |
+| Alternate | `<a b c>` | One per cycle |
+| Elongate | `a@2` | Double duration |
+| Replicate | `a!3` | Repeat 3x |
+| Parallel | `a,b` | Simultaneous |
+| Euclidean | `a(3,8)` | 3 hits over 8 |
+
+## Common Patterns
+
+```javascript
+s("bd*4")                 // 4 kicks per cycle (trance)
+s("~ hh ~ hh")            // Offbeat hi-hats
+s("~ sd ~ sd")            // Backbeat snare
+s("[bd sd]*2")            // Kick-snare groups
+s("bd*4, hh*8")           // Parallel layers
+s("bd(3,8)")              // Euclidean rhythm
+note("<c3 e3 g3 b3>")     // Chord progression per cycle
+```
+
+## Nesting and Complexity
+
+```javascript
+s("[bd [sd sd]] [hh hh hh hh]")  // Complex nesting
+note("[c3 e3] [g3 b3]")          // Melodic subdivisions
+s("[bd sd]*2, hh*16")            // Layered rhythm
+```
+
+**Techniques:**
+- Space separator: Sequential patterns (a b c)
+- Tilde (~): Rest/silence in pattern
+- Multiply (*): Repeat pattern n times (a*4)
+- Divide (/): Stretch pattern over n cycles
+- Brackets []: Subdivide into tighter steps
+- Angle brackets <>: Alternate one per cycle
+- @ symbol: Elongate duration (a@2 doubles)
+- ! symbol: Replicate pattern n times (a!3)
+- Comma (,): Parallel/simultaneous patterns
+- Euclidean notation: a(hits, steps) for rhythmic counting

package/skills/strudel-guidelines/reference/modulation.md

@@ -0,0 +1,22 @@
+# modulation: Dynamic Parameter Modulation
+
+**Guideline:** Replace static values with signal generators (sine, perlin, rand) to create organic evolution and movement.
+
+**Rationale:** Dynamic modulation adds life and interest; static values sound robotic and unmotivated.
+
+**Example:**
+```javascript
+// Classic filter sweep
+note("c2*8").sound("sawtooth")
+  .lpf(sine.range(200, 2000).slow(4))
+  .lpq(8)
+  .gain(0.5)
+```
+
+**Techniques:**
+- `sine.range(min, max).slow(n)`: Smooth, predictable LFO oscillation
+- `saw.range(min, max).slow(n)`: Linear ramps for gradual builds
+- `perlin.range(min, max)`: Smooth organic randomness (non-repetitive feel)
+- `rand.range(min, max)`: True random per event (glitch effects)
+- Common targets: `.lpf()`, `.gain()`, `.pan()`, `.room()`, `.lpq()` (resonance)
+- Cycle-based: `.crush("<3 4 5 6>")` or `.gain("<0.8 0.9 1 0.85>")` for stepped changes

package/skills/strudel-guidelines/reference/scales-harmony.md

@@ -0,0 +1,20 @@
+# filename: scales-harmony
+
+**Guideline:** Use `.scale()` to constrain notes to a key and chord notation for harmonically coherent compositions with intentional emotional expression.
+
+**Rationale:** Keys unify bass, chords, and melody; scales prevent dissonance and enable cohesive harmonic progression across all layers.
+
+**Example:**
+```javascript
+note("<a1 f1 c2 g1>*2").scale("A3:minor").sound("sawtooth")
+  .lpf(400).gain(0.5),
+note("<a3'min f3'maj c3'maj g3'maj>").sound("triangle")
+  .room(0.7).gain(0.3)
+```
+
+**Techniques:**
+- Scale constraint: `note("0 2 4 6").scale("C3:major")` to stay in key
+- Chord notation: `note("c3'maj")`, `note("c3'min7")`, `note("c3'aug")` for harmony
+- Progressions: i-VI-III-VII (trance), I-IV-V-I (house), vi-IV-I-V (pop)
+- Scale moods: Major (happy), Minor (sad), Phrygian (dark), Locrian (metal)
+- Transposition: `.add(12)` octave up, `.add(7)` fifth up for melodic variation

package/skills/strudel-guidelines/reference/sounds.md

@@ -0,0 +1,89 @@
+# sounds: Available Sounds and Instruments
+
+**Guideline:** Use verified drum samples and synthesis waveforms; fall back to synthesis for unreliable samples.
+
+**Rationale:** Not all sample names work in the web version. Verified sounds prevent silent patterns.
+
+**Example:**
+
+```javascript
+// Use verified drum sounds
+s("bd sd hh ~ hh")  // Always works in web version
+
+// Switch drum banks
+s("bd sd hh").bank("RolandTR808")  // TR-808 drums
+
+// Synthesis waveforms (always available)
+note("c3").sound("sine")      // Pure tone
+note("c3").sound("sawtooth")  // Bright sound
+
+// Combination: Drums + melody
+s("bd*4, hh*8").gain(0.7)
+note("c3 e3 g3 c4").sound("sine").sustain(0.5)
+
+// If melodic sample fails, use synthesis
+note("c2").sound("sawtooth").lpf(400)  // Fallback bass
+```
+
+## Verified Drum Samples
+
+```javascript
+s("bd")    // Kick drum
+s("sd")    // Snare
+s("hh")    // Hi-hat (closed)
+s("oh")    // Hi-hat (open)
+s("cp")    // Clap
+s("rim")   // Rimshot
+s("lt")    // Low tom
+s("mt")    // Mid tom
+s("ht")    // High tom
+```
+
+## Drum Banks
+
+```javascript
+s("bd sd hh").bank("RolandTR909")   // TR-909
+s("bd sd hh").bank("RolandTR808")   // TR-808
+// Also: RolandTR707, AkaiLinn, ViscoSpaceDrum
+```
+
+## Synthesis Waveforms (Always Available)
+
+```javascript
+note("c3").sound("sine")      // Pure, smooth
+note("c3").sound("sawtooth")  // Bright, rich
+note("c3").sound("square")    // Hollow, vintage
+note("c3").sound("triangle")  // Warm, soft
+```
+
+## Verified Melodic Samples
+
+```javascript
+note("c3").sound("piano")
+note("c3").sound("epiano")
+note("c3").sound("casio")
+note("c2").sound("gm_acoustic_bass")
+note("c2").sound("gm_synth_bass_1")
+```
+
+## Synthesis Alternative (for unreliable samples)
+
+```javascript
+// Instead of pad sample:
+note("c3").sound("sine")
+  .attack(0.5).sustain(2).release(1)
+  .room(0.8).gain(0.4)
+
+// Instead of bass sample:
+note("c2").sound("sawtooth").lpf(400).gain(0.6)
+```
+
+**Techniques:**
+- Verified drums: bd, sd, hh, oh, cp, rim, lt, mt, ht always work
+- Drum banks: RolandTR909, RolandTR808, RolandTR707, AkaiLinn, ViscoSpaceDrum
+- Synthesis waveforms: sine, sawtooth, square, triangle always available
+- Melodic samples: piano, epiano, casio, gm_acoustic_bass, gm_synth_bass_1
+- Fallback strategy: Use synthesis (sine/sawtooth) if samples fail
+- Envelope control: attack(), sustain(), release() for shaping
+- Effects: room(), lpf() (low-pass filter), gain() for tone shaping
+- Test in browser: Verify sounds work in web version before performance

package/skills/strudel-guidelines/reference/tempo-timing.md

@@ -0,0 +1,23 @@
+# tempo-timing: Tempo and Timing Control
+
+**Guideline:** Set tempo with `setcpm(BPM/4)` first, then use `.slow()`, `.fast()`, `.early()`, `.late()` for timing control.
+
+**Rationale:** Tempo anchors rhythmic relationships; timing modifiers create polyrhythms, syncopation, and groove feels.
+
+**Example:**
+```javascript
+setcpm(138/4)  // 138 BPM (uplifting trance)
+stack(
+  s("bd*4"),                    // Main beat
+  s("sd*3").slow(4/3),          // 3-per-cycle polyrhythm
+  note("c4").slow(4).room(0.8)  // 4-cycle pad
+)
+```
+
+**Techniques:**
+- `setcpm(BPM/4)`: Set tempo (128=house, 138=trance, 170=drum&bass)
+- `.slow(n)`: Pattern takes n cycles (half speed)
+- `.fast(n)`: Pattern plays n times per cycle (double speed)
+- `.early(0.125)`, `.late(0.125)`: Shift timing by fractions of cycle
+- Polyrhythms: `.slow(4/3)` creates 3-per-cycle over 4-beat backdrop
+- `.swing(0.2)`: Add medium swing feel

package/skills/terraform-guidelines/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: terraform-guidelines
+description: >-
+  Trigger on `.tf` files, Terraform modules, `*.tfvars`. Use when writing Terraform 1.12+ for infrastructure as code. Apply for module design, environment isolation, state management. Keywords: Terraform, modules, variables, outputs, remote state, for_each, dynamic blocks, locals, environment isolation.
+---
+
+# Terraform Coding Guidelines
+
+## Requirements
+
+- Terraform ≥ 1.12; remote state; pinned providers; fmt/validate.
+
+## Essentials
+
+- **Module design** - One responsibility per module, clear inputs/outputs, typed variables, see [reference/module-structure.md](reference/module-structure.md), [reference/module-definition.md](reference/module-definition.md), [reference/typed-variables.md](reference/typed-variables.md)
+- **Composition** - Thin root modules, compose child modules, use locals for computed values, see [reference/root-module.md](reference/root-module.md), [reference/locals.md](reference/locals.md)
+- **Environment isolation** - Separate envs (dirs + tfvars), isolate state per env, see [reference/root-module.md](reference/root-module.md), [reference/remote-state.md](reference/remote-state.md)
+- **Advanced patterns** - Dynamic blocks, for_each, count, see [reference/advanced-patterns.md](reference/advanced-patterns.md)
+
+## Progressive disclosure
+
+- Read [reference/module-structure.md](reference/module-structure.md) - When designing reusable Terraform modules
+- Read [reference/module-definition.md](reference/module-definition.md) - When defining module inputs, outputs, or resources
+- Read [reference/typed-variables.md](reference/typed-variables.md) - When adding variable validation or complex types
+- Read [reference/locals.md](reference/locals.md) - When computing intermediate values or reducing duplication
+- Read [reference/root-module.md](reference/root-module.md) - When organizing environment-specific configurations
+- Read [reference/remote-state.md](reference/remote-state.md) - When configuring state backend or state isolation
+- Read [reference/advanced-patterns.md](reference/advanced-patterns.md) - When using dynamic blocks, for_each, or count

package/skills/terraform-guidelines/reference/advanced-patterns.md

@@ -0,0 +1,88 @@
+# advanced-patterns: Advanced Terraform Patterns
+
+**Guideline:** Use data sources, dynamic blocks, and for_each/count appropriately
+
+**Rationale:** Advanced patterns enable flexible, maintainable infrastructure code
+
+**Example:**
+
+**Data Sources:**
+
+```hcl
+data "aws_ami" "amazon_linux_2" {
+  most_recent = true
+  owners      = ["amazon"]
+
+  filter {
+    name   = "name"
+    values = ["amzn2-ami-hvm-*-x86_64-gp2"]
+  }
+}
+
+data "aws_availability_zones" "available" {
+  state = "available"
+}
+
+resource "aws_instance" "app" {
+  ami           = data.aws_ami.amazon_linux_2.id
+  instance_type = "t3.micro"
+}
+```
+
+**Dynamic Blocks:**
+
+```hcl
+resource "aws_security_group" "this" {
+  name   = "${var.environment}-sg"
+  vpc_id = var.vpc_id
+
+  dynamic "ingress" {
+    for_each = var.ingress_rules
+
+    content {
+      from_port   = ingress.value.from_port
+      to_port     = ingress.value.to_port
+      protocol    = ingress.value.protocol
+      cidr_blocks = ingress.value.cidr_blocks
+    }
+  }
+}
+```
+
+**For_Each vs Count:**
+
+```hcl
+# ✅ Use for_each for map-based resources
+resource "aws_subnet" "private" {
+  for_each = local.subnet_cidrs
+
+  vpc_id            = aws_vpc.this.id
+  cidr_block        = each.value
+  availability_zone = each.key
+
+  tags = {
+    Name = "${var.environment}-private-${each.key}"
+  }
+}
+
+# ✅ Use count for simple repetition
+resource "aws_instance" "worker" {
+  count = var.worker_count
+
+  ami           = data.aws_ami.amazon_linux_2.id
+  instance_type = "t3.micro"
+
+  tags = {
+    Name = "${var.environment}-worker-${count.index + 1}"
+  }
+}
+
+# ❌ Avoid count with lists (order matters, causes unnecessary recreation)
+```
+
+**Techniques:**
+- **Data sources:** Query existing AWS resources without importing or creating them
+- **Dynamic blocks:** Generate repeated nested blocks from variables or locals
+- **For_each with maps:** Maintain consistent resource names when order changes
+- **Count for simple repetition:** Use only for stateless resource duplication
+- **Avoid count with lists:** Order changes cause unnecessary recreation and state corruption

package/skills/terraform-guidelines/reference/locals.md

@@ -0,0 +1,53 @@
+# locals: Computed Values with Locals
+
+**Guideline:** Use locals block for computed values, transformations, and conditional logic
+
+**Rationale:** Locals reduce duplication, improve readability, and centralize computation logic
+
+**Example:**
+
+```hcl
+locals {
+  # Merge tags
+  common_tags = merge(
+    var.tags,
+    {
+      Environment = var.environment
+      ManagedBy   = "terraform"
+      Timestamp   = timestamp()
+    }
+  )
+
+  # Calculate values
+  subnet_count = length(var.availability_zones)
+
+  # Conditional values
+  instance_type = var.environment == "prod" ? "t3.large" : "t3.micro"
+
+  # Complex transformations
+  subnet_cidrs = {
+    for i, az in var.availability_zones :
+    az => cidrsubnet(var.vpc_cidr, 8, i)
+  }
+
+  # Flatten nested structures
+  security_rules = flatten([
+    for sg in var.security_groups : [
+      for rule in sg.rules : {
+        sg_name   = sg.name
+        from_port = rule.from_port
+        to_port   = rule.to_port
+        protocol  = rule.protocol
+      }
+    ]
+  ])
+}
+```
+
+**Techniques:**
+- **Tag merging:** Combine common tags with resource-specific tags using merge()
+- **Calculated values:** Compute derived values like counts and indices once
+- **Conditional logic:** Use ternary operators for environment-specific resource sizing
+- **CIDR subnetting:** Transform VPC CIDR into subnet ranges using cidrsubnet()
+- **Flattening:** Collapse nested structures for iteration with flatten()
+