diff --git a/tech_docs/Infrastructure-as-Files.md b/tech_docs/Infrastructure-as-Files.md
new file mode 100644
index 0000000..081a574
--- /dev/null
+++ b/tech_docs/Infrastructure-as-Files.md
@@ -0,0 +1,101 @@
+You're absolutely right to call out loose terminology—this space is full of overloaded terms, and I should be more precise. Let’s tighten this up with **rigorous definitions** and clarify where tools like Kubernetes and Ansible fit.  
+
+---
+
+### **1. Strict Definitions**  
+#### **Infrastructure-as-Files (IaF)**  
+- **What it is**:  
+  - **Static, declarative files** (YAML, JSON, HCL) that describe desired state.  
+  - **No logic** (no loops, conditionals, or dynamic generation).  
+  - **Manual/scripted application** (e.g., `kubectl apply -f`, `ansible-playbook`).  
+  - **No state management** (applying files doesn’t track drift).  
+
+- **Examples**:  
+  - Kubernetes manifests (`deployment.yaml`).  
+  - Ansible playbooks (if purely declarative).  
+  - Terraform `*.tf` files (if no dynamic blocks/modules).  
+
+#### **Infrastructure-as-Code (IaC)**  
+- **What it is**:  
+  - **Programmatic** (Terraform, Pulumi, CDK) with logic (loops, conditionals, functions).  
+  - **Stateful** (tracks actual vs. desired state, e.g., Terraform state files).  
+  - **Automated workflows** (plan/apply, drift detection).  
+
+- **Key difference**:  
+  - IaC **generates** infrastructure definitions dynamically; IaF **is** the definition.  
+
+#### **GitOps**  
+- **What it is**:  
+  - A **methodology** where Git is the source of truth, and changes are **automatically applied** (e.g., ArgoCD, Flux).  
+  - Can use **IaF or IaC** under the hood (e.g., Kubernetes YAML or Terraform plans).  
+
+---
+
+### **2. Clarifying Kubernetes and Ansible**  
+#### **Kubernetes: IaF by Default, But Can Be IaC/GitOps**  
+- **Native workflow**: IaF (apply YAML files manually).  
+  ```sh
+  kubectl apply -f deployment.yaml  # Pure IaF
+  ```  
+- **IaC overlay**: Tools like `kustomize` (templating), Helm (logic), or Crossplane (provisioning) add IaC capabilities.  
+- **GitOps**: ArgoCD watches Git repos and auto-applies YAML (still IaF, but automated).  
+
+#### **Ansible: Hybrid IaF/IaC**  
+- **IaF mode**: Static playbooks (no dynamic logic).  
+  ```yaml
+  # playbook.yml (IaF)
+  - hosts: webservers
+    tasks:
+      - name: Install nginx
+        apt: name=nginx state=present
+  ```  
+- **IaC mode**: When using Jinja2 templating, loops, or dynamic inventories:  
+  ```yaml
+  # IaC-like (dynamic)
+  - name: Install packages
+    apt: "name={{ item }} state=present"
+    loop: "{{ packages }}"
+  ```  
+
+---
+
+### **3. Why the Confusion?**  
+- **Overlap**: Many tools support both modes (e.g., Ansible can be IaF or IaC).  
+- **Marketing**: Vendors blur terms (e.g., calling Helm "IaC" when it’s templated IaF).  
+- **Evolution**: GitOps emerged as a pattern atop IaF/IaC.  
+
+---
+
+### **4. Decision Tree: Is It IaF or IaC?**  
+| **Tool/File**       | **IaF?** | **IaC?** | **Notes** |  
+|----------------------|----------|----------|-----------|  
+| Kubernetes YAML      | ✅ Yes   | ❌ No    | Unless templated (Helm/Kustomize). |  
+| Terraform `*.tf`     | ❌ No    | ✅ Yes   | Dynamic blocks/modules make it IaC. |  
+| Ansible (static)     | ✅ Yes   | ❌ No    | Pure YAML playbooks. |  
+| Ansible (dynamic)    | ❌ No    | ✅ Yes   | Uses Jinja2/loops. |  
+| Docker Compose       | ✅ Yes   | ❌ No    | Static YAML. |  
+| Pulumi (Python/TS)  | ❌ No    | ✅ Yes   | Full programming model. |  
+
+---
+
+### **5. Key Takeaways**  
+1. **IaF** = Static files, no logic, manual apply.  
+   - Example: Raw Kubernetes YAML, basic Ansible playbooks.  
+2. **IaC** = Code (logic, state, automation).  
+   - Example: Terraform, Pulumi, dynamic Ansible.  
+3. **GitOps** = Automation layer atop IaF/IaC.  
+   - Example: ArgoCD syncing Kubernetes YAML from Git.  
+
+---
+
+### **6. Fixing My Earlier Mistakes**  
+- **Kubernetes**: Default is IaF, but **not all Kubernetes workflows are IaF** (Helm/Kustomize add IaC-like features).  
+- **Ansible**: Can be **IaF or IaC** depending on use.  
+- **GitOps ≠ IaF**: GitOps automates IaF/IaC; they’re orthogonal concepts.  
+
+---
+
+### **Final Answer**  
+**IaF is a subset of IaC tooling**—it’s the "dumb YAML" layer. When you add logic/automation, it becomes IaC or GitOps. Kubernetes and Ansible **default to IaF** but can cross into IaC territory with advanced features.  
+
+Would you like concrete examples (e.g., "Here’s how the same app is defined in IaF vs. IaC")? I’m happy to dive deeper.
\ No newline at end of file