diff --git a/specs/305-markdown-file-creation-fcf712/feature.yaml b/specs/305-markdown-file-creation-fcf712/feature.yaml
new file mode 100644
index 000000000..73bc2b04f
--- /dev/null
+++ b/specs/305-markdown-file-creation-fcf712/feature.yaml
@@ -0,0 +1,38 @@
+feature:
+  id: "305-markdown-file-creation-fcf712"
+  name: "markdown-file-creation-fcf712"
+  number: 305
+  branch: "feat/305-markdown-file-creation-fcf712"
+  lifecycle: "research"
+  createdAt: "2026-04-01T11:01:32Z"
+status:
+  phase: "implementation-complete"
+  progress:
+    completed: 3
+    total: 3
+    percentage: 100
+  currentTask: null
+  lastUpdated: "2026-04-01T11:09:14.289Z"
+  lastUpdatedBy: "feature-agent:implement"
+  completedPhases:
+    - "analyze"
+    - "requirements"
+    - "research"
+    - "plan"
+    - "phase-1"
+    - "phase-2"
+validation:
+  lastRun: null
+  gatesPassed: []
+  autoFixesApplied: []
+tasks:
+  current: null
+  blocked: []
+  failed: []
+checkpoints:
+  - phase: "feature-created"
+    completedAt: "2026-04-01T11:01:32Z"
+    completedBy: "feature-agent"
+errors:
+  current: null
+  history: []
diff --git a/specs/305-markdown-file-creation-fcf712/plan.yaml b/specs/305-markdown-file-creation-fcf712/plan.yaml
new file mode 100644
index 000000000..2a79b7bee
--- /dev/null
+++ b/specs/305-markdown-file-creation-fcf712/plan.yaml
@@ -0,0 +1,162 @@
+name: "markdown-file-creation-fcf712"
+summary: |
+  Simple two-phase approach: (1) Create test-n33d8c.md with H1 heading and prose content
+  using Python stdlib, ensuring UTF-8 encoding and Unix LF line endings,
+  (2) Execute git workflow (add, commit, push) using git CLI to feature branch.
+  Follows established pattern from 300+ prior features (269-304) with no new dependencies,
+  architectural changes, or complex technical decisions required.
+
+relatedFeatures:
+  - 304
+  - 303
+  - 302
+  - 269
+
+technologies:
+  - "Python 3.x (standard library: pathlib, open)"
+  - "Git CLI"
+  - "Markdown syntax"
+
+relatedLinks:
+  - title: "CommonMark Specification"
+    url: "https://spec.commonmark.org/"
+  - title: "UTF-8 Encoding Standard"
+    url: "https://en.wikipedia.org/wiki/UTF-8"
+
+phases:
+  - id: phase-1
+    name: "File Creation"
+    description: |
+      Create test-n33d8c.md with H1 markdown heading and 2-3 sentences of coherent prose content,
+      ensuring UTF-8 encoding without BOM and Unix LF line endings.
+    parallel: false
+
+  - id: phase-2
+    name: "Git Workflow"
+    description: |
+      Stage file with git add, commit with conventional message format,
+      and push to remote feature branch with upstream tracking configured.
+    parallel: false
+
+filesToCreate:
+  - "test-n33d8c.md"
+
+filesToModify: []
+
+openQuestions: []
+
+content: |
+  ## Architecture Overview
+
+  Feature 305 is a pure file creation and git workflow task with no application code,
+  logic, or architectural complexity. The implementation fits into the established
+  markdown-file-creation pattern proven across 300+ prior features (269-304).
+
+  The approach is straightforward:
+  1. Create a single markdown file at the repository root using Python's standard library
+  2. Write coherent prose content with proper markdown formatting
+  3. Execute standard git workflow operations (add, commit, push)
+
+  No application code, testing infrastructure, or configuration changes are involved.
+  The feature is independent and isolated — file creation does not integrate with
+  or impact any application logic, agents, flows, or tools.
+
+  ## Key Design Decisions
+
+  ### File Creation Method: Python Standard Library (pathlib/open)
+
+  **Chosen:** Use Python's pathlib.Path or built-in open() for file I/O
+
+  **Alternatives Considered:**
+  - Third-party file I/O libraries (requests, click, etc.) — unnecessary overhead; standard library is proven across 300+ prior features
+  - Shell script or bash subprocess — Python is the established pattern for this repository
+
+  **Rationale:**
+  Python's pathlib and open() are sufficient for this trivial file creation task.
+  All 300+ preceding markdown-file-creation features use Python stdlib, establishing clear precedent.
+  No external dependencies are needed. Using stdlib keeps the codebase simple and maintainable.
+
+  ### Text Encoding and Line Endings: UTF-8 without BOM, Unix LF
+
+  **Chosen:** UTF-8 encoding, Unix LF line endings (\n), no Byte Order Mark (BOM)
+
+  **Alternatives Considered:**
+  - UTF-16 or other encodings — UTF-8 is the standard for markdown files and used across all 300+ existing files
+  - Windows CRLF line endings — Unix LF is the repository standard and required by the specification
+  - Manual encoding handling — Python's open() with encoding='utf-8' handles this automatically and correctly
+
+  **Rationale:**
+  UTF-8 without BOM is the established standard across all existing test files and markdown documents.
+  Python's default text mode write with encoding='utf-8' produces correct UTF-8 without BOM.
+  Unix LF line endings are enforced by writing in text mode on Unix systems.
+  This approach requires no special handling and follows 300+ proven implementations.
+
+  ### Content Generation: Manual Prose Composition
+
+  **Chosen:** Hand-write 2-3 sentences of coherent, meaningful prose about any topic
+
+  **Alternatives Considered:**
+  - AI-generated content (language models) — creates unnecessary complexity and dependency risk for a simple task
+  - Random text generators or lorem ipsum — violates requirement for coherent, meaningful prose
+  - External content APIs — adds network dependency and complexity; unnecessary for a straightforward task
+
+  **Rationale:**
+  This feature requires 2-3 sentences of coherent, meaningful prose.
+  Manual composition is trivial for this scope and guarantees content quality and appropriateness.
+  All 300+ prior features use hand-written prose content, establishing the clear precedent.
+
+  ### Git Workflow Implementation: Native Git CLI
+
+  **Chosen:** Execute git CLI commands (git add, git commit, git push) via shell
+
+  **Alternatives Considered:**
+  - GitPython library — adds external dependency for simple git operations that are already well-proven with CLI
+  - Manual git protocol implementation — unnecessary and error-prone compared to trusted git CLI
+
+  **Rationale:**
+  All 300+ preceding markdown-file-creation features use git CLI commands.
+  Git CLI is available in the environment and produces the expected commit history and branch state.
+  The operations are mechanical and simple: add one file, commit, push to feature branch.
+  CLI commands are transparent, auditable, and require no additional dependencies.
+
+  ### File Placement and Naming: Repository Root, Pre-specified Filename
+
+  **Chosen:** Repository root directory with exact filename test-n33d8c.md (pre-specified)
+
+  **Alternatives Considered:**
+  - Subdirectories (tests/, fixtures/, etc.) — specification and 300+ prior features explicitly use repository root
+  - Generated filenames or naming schemes — specification pre-specifies exact filename; no generation needed
+
+  **Rationale:**
+  The specification mandates filename test-n33d8c.md at repository root (FR-1, FR-2).
+  All 300+ preceding files follow identical placement and naming pattern.
+  File naming is pre-specified — no decision needed.
+
+  ## Implementation Strategy
+
+  **Phase 1: File Creation (5-7 minutes)**
+  - Create test-n33d8c.md at repository root
+  - Write H1 markdown heading as first line
+  - Add blank line separator
+  - Write 2-3 sentences of coherent prose content about any topic
+  - Verify UTF-8 encoding without BOM and Unix LF line endings
+
+  **Phase 2: Git Workflow (3-8 minutes)**
+  - Stage file with git add test-n33d8c.md
+  - Create commit with conventional message: "feat(305): create markdown file test-n33d8c.md with prose content"
+  - Push to feature branch with upstream tracking configured
+
+  Both phases are sequential and non-parallel. File creation must complete before git operations can begin.
+  This ordering ensures we validate the file structure before committing to version control.
+
+  ## Risk Mitigation
+
+  | Risk | Mitigation |
+  | ---- | ---------- |
+  | Incorrect file encoding (UTF-16, ASCII, or BOM present) | Use Python text mode with explicit encoding='utf-8' parameter; verify output with file -i command |
+  | CRLF line endings instead of Unix LF | Write in Python text mode on Unix system; verify with file command or od -c |
+  | File not created at correct location (wrong directory) | Use absolute path or pathlib.Path.cwd() / filename to ensure repository root placement |
+  | Prose content lacks coherence or appropriate tone | Manual composition with careful review ensures quality and appropriateness |
+  | Git commit message format incorrect | Use exact conventional commit format specified in requirements; copy-paste message if needed |
+  | Feature branch not configured for upstream push | Configure upstream tracking with git push -u origin <branch> |
+  | File size outside expected 400-600 byte range | Specification is flexible on exact size; 2-3 sentences naturally produce file in expected range |
diff --git a/specs/305-markdown-file-creation-fcf712/research.yaml b/specs/305-markdown-file-creation-fcf712/research.yaml
new file mode 100644
index 000000000..1201f2b18
--- /dev/null
+++ b/specs/305-markdown-file-creation-fcf712/research.yaml
@@ -0,0 +1,269 @@
+name: "markdown-file-creation-fcf712"
+summary: >
+  Feature 305 follows the well-established markdown-file-creation pattern proven across 300+ prior features (269-304).
+  Implementation requires only file creation and git workflow with no architectural decisions,
+  new dependencies, or security/performance concerns beyond standard practices.
+
+relatedFeatures:
+  - 304
+  - 303
+  - 302
+  - 269
+
+technologies:
+  - "Python 3.x (standard library only)"
+  - "Git CLI"
+  - "Markdown syntax"
+
+relatedLinks:
+  - title: "CommonMark Specification"
+    url: "https://spec.commonmark.org/"
+  - title: "UTF-8 Encoding Standard"
+    url: "https://en.wikipedia.org/wiki/UTF-8"
+
+decisions:
+  - title: "File Creation Method"
+    chosen: "Python standard library (pathlib.Path or built-in open())"
+    rejected:
+      - "Third-party file I/O libraries (requests, click, etc.) — unnecessary overhead; standard library is already proven across 300+ prior features"
+      - "Shell script or bash subprocess — Python is the established pattern for this repository"
+    rationale: >
+      Python's pathlib or built-in open() are sufficient for this trivial file creation task.
+      All 300+ preceding markdown-file-creation features use Python stdlib, establishing clear precedent.
+      No external dependencies are needed. Using stdlib keeps the codebase simple and maintainable.
+
+  - title: "Text Encoding and Line Ending Handling"
+    chosen: "UTF-8 encoding without BOM, Unix LF line endings enforced during write"
+    rejected:
+      - "UTF-16 or other encodings — UTF-8 is the standard for markdown files and is used across all 300+ existing files"
+      - "Windows CRLF line endings — Unix LF is the repository standard and required by the specification"
+      - "Manual encoding handling — Python's open() with encoding='utf-8' handles this automatically and correctly"
+    rationale: >
+      UTF-8 without BOM is the established standard across all existing test files and markdown documents.
+      Python's default text mode write with encoding='utf-8' produces correct UTF-8 without BOM.
+      Unix LF line endings (\n) are enforced by writing in text mode on Unix systems (verified by file command on existing files).
+      This approach requires no special handling and follows 300+ proven implementations.
+
+  - title: "Content Generation and Validation"
+    chosen: "Manual prose generation with inline validation of sentence count and grammatical correctness"
+    rejected:
+      - "AI-generated content (language models) — creates unnecessary complexity and dependency risk for a simple task"
+      - "Random text generators or lorem ipsum — violates requirement for coherent, meaningful prose"
+      - "External content APIs — adds network dependency and complexity; unnecessary for a straightforward task"
+    rationale: >
+      This feature requires 2-3 sentences of coherent, meaningful prose about any topic.
+      Manual composition is trivial for this scope and guarantees content quality and appropriateness.
+      No algorithmic content generation is needed — this is a data/content task, not a logic task.
+      All 300+ prior features use hand-written prose content, establishing the clear precedent.
+
+  - title: "Git Workflow Implementation"
+    chosen: "Native git CLI commands executed via shell (subprocess or direct bash commands)"
+    rejected:
+      - "GitPython library — adds external dependency for simple git operations that are already well-proven with CLI"
+      - "Manual git protocol implementation — unnecessary and error-prone compared to trusted git CLI"
+    rationale: >
+      All 300+ preceding markdown-file-creation features use git CLI commands (git add, git commit, git push).
+      Git CLI is available in the environment and produces the expected commit history and branch state.
+      The operations are mechanical and simple: add one file, commit, push to feature branch.
+      CLI commands are transparent, auditable, and require no additional dependencies.
+
+  - title: "File Placement and Naming"
+    chosen: "Repository root directory with exact filename test-n33d8c.md (pre-specified)"
+    rejected:
+      - "Subdirectories (tests/, fixtures/, etc.) — specification and 300+ prior features explicitly use repository root"
+      - "Generated filenames or naming schemes — specification pre-specifies exact filename; no generation needed"
+    rationale: >
+      The specification mandates filename test-n33d8c.md at repository root (FR-1, FR-2).
+      All 300+ preceding files follow identical placement and naming pattern.
+      File naming is pre-specified — no decision needed.
+
+openQuestions: []
+
+content: |
+  ## Research Summary
+
+  Feature 305 is the 305th iteration of an established markdown-file-creation pattern with 300+ existing implementations
+  (features 269-304 and beyond). The feature is trivial in technical scope: create a single markdown file with specified
+  format and git workflow.
+
+  **Key Finding:** No architectural decisions, new dependencies, or complex technical considerations are needed.
+  This feature follows proven patterns established across the prior 300+ identical features.
+
+  ---
+
+  ## Technology Decisions
+
+  ### 1. File Creation Method
+
+  **Chosen:** Python standard library (pathlib.Path or open())
+
+  **Rejected:**
+  - Third-party libraries (requests, click, etc.) — unnecessary overhead; standard library proven across 300+ features
+  - Shell/bash subprocess — Python is the established pattern for file operations in this repository
+
+  **Rationale:**
+  All 300+ preceding markdown-file-creation features use Python's standard library for file I/O.
+  The pathlib module or open() function are sufficient and appropriate for creating a single text file (~400-600 bytes).
+  No external dependencies are needed or justified. Using stdlib maintains simplicity and consistency.
+
+  ### 2. Text Encoding and Line Endings
+
+  **Chosen:** UTF-8 encoding without BOM; Unix LF line endings (\n)
+
+  **Rejected:**
+  - Other encodings (UTF-16, ASCII, Latin-1) — UTF-8 is the standard for markdown and all existing files use UTF-8
+  - Windows CRLF line endings (\r\n) — Unix LF is the repository standard and explicitly required by spec (NFR-2)
+  - Manual byte-level encoding handling — Python's text mode handles encoding correctly by default
+
+  **Rationale:**
+  UTF-8 is the de facto standard for markdown files and is confirmed across all 300+ existing test files.
+  Python's open(..., encoding='utf-8') produces correct UTF-8 text without BOM when writing in text mode.
+  Unix LF line endings are produced automatically by Python's text mode on Unix systems.
+  File verification of existing files confirms this behavior: "ASCII text, with very long lines" (no CRLF present).
+
+  ### 3. Content Generation
+
+  **Chosen:** Manual prose composition (2-3 sentences of coherent, meaningful content)
+
+  **Rejected:**
+  - AI language models or generative tools — unnecessary complexity for straightforward prose task
+  - Random text generators or lorem ipsum — violates requirement for coherent, meaningful prose (FR-6)
+  - External content APIs or services — adds network dependencies; unjustified for a simple task
+
+  **Rationale:**
+  The requirement is simple: 2-3 grammatically correct sentences about any topic (FR-5, FR-6, FR-7).
+  Manual composition is trivial for this scope and guarantees content quality and appropriateness.
+  All 300+ prior features use hand-written prose; this is the established pattern.
+  No algorithmic or computational complexity is present — this is a straightforward content task.
+
+  ### 4. Git Workflow
+
+  **Chosen:** Native Git CLI commands (git add, git commit, git push) executed via shell
+
+  **Rejected:**
+  - GitPython library — adds external dependency for simple, proven git operations
+  - Manual git protocol or internal implementation — error-prone; unnecessary when CLI is available
+
+  **Rationale:**
+  All 300+ preceding features use git CLI commands (confirmed in git log: features 302-304 show "Create markdown file ... with prose content").
+  Git CLI is available in the environment and produces expected commit history and branch tracking.
+  The operations are mechanical: git add one file, commit with conventional message, push to feature branch.
+  CLI commands are transparent, auditable, and integrate naturally with the shell environment.
+
+  ### 5. File Placement and Naming
+
+  **Chosen:** Repository root directory; filename: test-n33d8c.md (pre-specified)
+
+  **Rejected:**
+  - Subdirectories (tests/, fixtures/, etc.) — specification and all 300+ prior files use repository root (FR-1)
+  - Generated or parameterized filenames — specification pre-specifies exact filename (FR-2)
+
+  **Rationale:**
+  The specification explicitly requires filename "test-n33d8c.md" at repository root (FR-1, FR-2).
+  All 300+ preceding files follow identical placement pattern at repository root.
+  No naming decision or generation is needed — filename is pre-specified by requirements.
+
+  ---
+
+  ## Library Analysis
+
+  | Library/Tool | Purpose | Decision | Reasoning |
+  | ----------- | ------- | -------- | --------- |
+  | pathlib (Python stdlib) | File path manipulation and creation | Use | Built-in, proven across 300+ features, no external dependency |
+  | open() (Python builtin) | Write markdown content to file | Use | Built-in, handles UTF-8 encoding and LF line endings correctly |
+  | subprocess / shell | Execute git commands (add, commit, push) | Use | Git CLI is standard, proven across 300+ prior features |
+  | Git CLI | Version control workflow | Use | Already installed in environment, standard tool for all 300+ features |
+  | Third-party file I/O libraries | File operations | Reject | Standard library is sufficient; external dependencies unjustified |
+  | GitPython | Git operations via Python | Reject | Shell CLI is standard pattern; library adds unnecessary complexity |
+  | AI content generation | Generate prose content | Reject | Manual composition is sufficient; adds complexity and dependency risk |
+
+  ---
+
+  ## Security Considerations
+
+  **Content Appropriateness (Low Risk):**
+  - Requirement specifies prose content must be appropriate for professional repository (NFR-5)
+  - Mitigation: Manual content composition ensures appropriateness; no offensive or inappropriate material will be included
+  - No code execution or injection vectors present — file is plain markdown text
+
+  **File Encoding Safety (No Risk):**
+  - UTF-8 encoding without BOM is standard and safe; no encoding-based vulnerabilities
+  - LF line endings are standard Unix format; CRLF is not used
+
+  **Git Workflow Safety (Low Risk):**
+  - Git operations are standard and non-destructive: add, commit, push
+  - Feature branch is pre-created; no force-push or destructive operations needed
+  - Conventional commit message format is established pattern
+
+  **File System Safety (No Risk):**
+  - Single file creation at repository root; no existing files modified or deleted
+  - File size is trivial (~400-600 bytes); no resource exhaustion concerns
+
+  **Overall Security Assessment:** No significant security implications. This is a straightforward data file creation task with
+  minimal risk. Content appropriateness is the only security consideration, which is addressed through manual composition.
+
+  ---
+
+  ## Performance Implications
+
+  **Performance Assessment (No Concerns):**
+
+  - **File Creation:** Single file write (~400-600 bytes) is negligible; no performance optimization needed
+  - **No algorithmic complexity:** Content is manually composed; no computation-intensive operations
+  - **No network operations:** File is created locally; no network latency or I/O contention
+  - **Git operations:** Standard add/commit/push operations are lightweight and well-optimized by git
+  - **Scalability:** Feature is isolated; does not introduce any scalability concerns or new patterns
+  - **Storage:** 400-600 byte file is trivial; no impact on repository size or performance
+
+  **Conclusion:** No performance optimizations needed or applicable. This feature follows the exact pattern of 300+ prior
+  features with no performance concerns observed.
+
+  ---
+
+  ## Architecture Notes
+
+  ### Integration with Existing Codebase
+
+  **Repository Structure:**
+  - Feature follows established pattern of markdown-file-creation features (269-304+)
+  - File is placed at repository root alongside 300+ existing test markdown files (test-*.md)
+  - No integration with application code (/src/sheep/), configuration, or testing infrastructure
+
+  **Git Workflow:**
+  - Feature branch `feat/305-markdown-file-creation-fcf712` is pre-created
+  - Commit message follows conventional commit format established across all 300+ prior features
+  - No branch merging, rebasing, or conflict resolution needed
+
+  **Implementation Approach:**
+  - Pure file creation and git workflow; no code, logic, or architecture involved
+  - No dependencies on or impacts to existing modules, agents, flows, or tools
+  - Independent of application infrastructure — this is a data/content task
+
+  ### Consistency with Established Patterns
+
+  Feature 305 is explicitly designed to follow the proven pattern from features 269-304 (35+ recent implementations).
+  All decisions made above align with established practices across these 300+ identical features:
+  - Python stdlib for file operations
+  - Manual prose content generation
+  - Git CLI for version control
+  - Repository root placement
+  - Conventional commit message format
+
+  No new patterns, tools, or approaches are introduced.
+
+  ---
+
+  ## Conclusion
+
+  Feature 305 is a low-complexity, well-established feature with clear precedent across 300+ prior implementations.
+  All technical decisions align with proven patterns from features 269-304. No new dependencies, architectural changes,
+  or complex technical considerations are needed.
+
+  **Implementation is straightforward:**
+  1. Create test-n33d8c.md with H1 heading and 2-3 sentences of prose content
+  2. Ensure UTF-8 encoding and Unix LF line endings (automatic via Python text mode)
+  3. Stage file with git add
+  4. Commit with conventional message format
+  5. Push to feature branch
+
+  Estimated implementation time: 10-15 minutes (consistent with established pattern).
diff --git a/specs/305-markdown-file-creation-fcf712/spec.yaml b/specs/305-markdown-file-creation-fcf712/spec.yaml
new file mode 100644
index 000000000..53c3a75b5
--- /dev/null
+++ b/specs/305-markdown-file-creation-fcf712/spec.yaml
@@ -0,0 +1,128 @@
+name: "markdown-file-creation-fcf712"
+number: 305
+branch: "feat/305-markdown-file-creation-fcf712"
+oneLiner: "Create markdown file test-n33d8c.md with H1 heading and 2-3 sentences of prose content"
+summary: |
+  Create a single markdown file named test-n33d8c.md at the repository root containing an H1 markdown heading and 2-3 sentences of coherent prose content. Follows the established pattern from 300+ preceding markdown-file-creation features (269-304), with git staging, commit, and push to feature branch.
+phase: "Requirements"
+sizeEstimate: "S"
+
+relatedFeatures:
+  - 304
+  - 303
+  - 302
+
+technologies:
+  - "Python 3.x"
+  - "Git CLI"
+  - "Markdown syntax"
+
+relatedLinks:
+  - title: "CommonMark Specification"
+    url: "https://spec.commonmark.org/"
+
+openQuestions: []
+
+content: |
+  ## Problem Statement
+
+  Feature 305 requires creating a single markdown file named test-n33d8c.md with:
+  - An H1 markdown heading (# Title) as the first line
+  - A blank line separator between heading and prose
+  - Exactly 2-3 sentences of coherent prose content about any topic
+  - UTF-8 encoding with no BOM (byte order mark)
+  - Unix LF line endings (not CRLF)
+  - Git staging, commit with conventional message format, and push to remote
+  - File placed at repository root
+
+  This is the 305th iteration of a well-established markdown-file-creation feature pattern successfully executed in features 269-304 and beyond. The repository contains 300+ test markdown files following this identical pattern, providing clear precedent for implementation approach and content structure.
+
+  ## Success Criteria
+
+  - [ ] File created at repository root with exact filename "test-n33d8c.md"
+  - [ ] File begins with an H1 markdown heading (format: # Title)
+  - [ ] Blank line separates H1 heading from prose content
+  - [ ] File contains exactly 2-3 complete sentences of coherent prose
+  - [ ] Prose content is meaningful, readable, and appropriate
+  - [ ] File encoded as UTF-8 without BOM (Byte Order Mark)
+  - [ ] File uses Unix LF line endings (not CRLF)
+  - [ ] File size is naturally between 400-600 bytes (expected outcome of structure)
+  - [ ] File successfully staged with git add command
+  - [ ] Commit created with conventional format: "feat(305): create markdown file test-n33d8c.md with prose content"
+  - [ ] Commit successfully pushed to feature branch (feat/305-markdown-file-creation-fcf712)
+  - [ ] No other files in repository modified or created
+  - [ ] Feature branch tracking properly configured for upstream push
+
+  ## Functional Requirements
+
+  - **FR-1**: The markdown file must be created at the repository root
+  - **FR-2**: File must have the exact filename "test-n33d8c.md"
+  - **FR-3**: File must begin with an H1 markdown heading in the format "# Title" on the first line
+  - **FR-4**: A blank line must separate the H1 heading from the prose content
+  - **FR-5**: File must contain exactly 2-3 complete, grammatically correct sentences
+  - **FR-6**: Prose content must be coherent, meaningful, and readable (not gibberish)
+  - **FR-7**: Prose content may be about any topic (no topic restrictions)
+  - **FR-8**: File must be staged using "git add test-n33d8c.md"
+  - **FR-9**: Commit must be created with conventional commit message format: "feat(305): create markdown file test-n33d8c.md with prose content"
+  - **FR-10**: Commit must be pushed to the feature branch with upstream tracking configured
+
+  ## Non-Functional Requirements
+
+  - **NFR-1**: File encoding must be UTF-8 without BOM (Byte Order Mark)
+  - **NFR-2**: Line endings must be Unix LF format (\\n), not Windows CRLF (\\r\\n)
+  - **NFR-3**: File size should naturally range from 400-600 bytes based on content structure
+  - **NFR-4**: Implementation must follow the established pattern proven across features 269-304
+  - **NFR-5**: Content must be appropriate for a professional repository (no offensive or inappropriate material)
+  - **NFR-6**: Implementation should complete within the estimated 10-15 minute timeframe
+  - **NFR-7**: No modifications to source code (/src/sheep/), tests, or configuration files
+  - **NFR-8**: Git workflow must follow conventional commit standards and proper branch management
+
+  ## Affected Areas
+
+  | Area | Impact | Reasoning |
+  | ---- | ------ | --------- |
+  | Repository Root Directory | Low | Adds one new markdown file (test-n33d8c.md) to existing collection of 300+ test files; no modifications to existing files or directory structure |
+  | File System | Low | Single file creation operation (~400-600 bytes); no directory structure changes, no deletions or overwrites |
+  | Git Repository | Low | Standard single commit and push following established pattern from features 269-304; no branch/merge complexity, no destructive operations |
+  | Source Code | None | Feature is purely file creation; does not depend on or impact any source code in /src/sheep/ or elsewhere |
+  | Specs Directory | Low | Updates only this spec.yaml file as part of requirements phase; no impact on other specs or configurations |
+  | Application Logic | None | Feature has no impact on application behavior, agents, flows, or tools |
+
+  ## Dependencies
+
+  **External Dependencies**:
+  - **Git CLI**: Executable for staging, committing, pushing (subprocess or direct shell commands)
+  - **Python Standard Library**: pathlib for file I/O, os for file system operations (no new dependencies)
+
+  **No New Dependencies Required**: All required infrastructure (pathlib, git) is already available and proven across 300+ prior features.
+
+  **Pre-requisites**:
+  - Feature branch `feat/305-markdown-file-creation-fcf712` must exist (pre-created)
+  - Write access to repository root directory
+  - Git repository initialized with standard configuration
+  - Git user configured (name and email)
+
+  ## Size Estimate
+
+  **S** (Small — approximately 10-15 minutes)
+
+  **Rationale**:
+  - Well-established pattern with 300+ identical test files providing clear precedent
+  - Flexible topic selection with no research or architectural decisions needed
+  - Single file with minimal, well-understood content format (one H1 heading + 2-3 sentences of prose)
+  - No testing, documentation, or configuration changes required
+  - File naming (test-n33d8c.md) is pre-specified, eliminating naming decisions
+  - Git workflow is mechanical and follows exact precedent from 35+ recent implementations (features 269-304)
+  - Estimated breakdown: 5 min (compose/write file) + 3 min (validate structure) + 2-5 min (git workflow) = 10-15 min total
+
+  ## Product Decisions
+
+  **Scope Decisions (All Confirmed by Precedent)**:
+  - Topic selection: Free-form (any topic allowed) — confirmed across existing files with diverse subjects
+  - Content length: Exactly 2-3 sentences (not flexible) — specified requirement
+  - File location: Repository root only — established pattern
+  - Git workflow: Add, commit, push to feature branch — standard workflow
+
+  ---
+
+  Requirements phase complete — functional and non-functional requirements defined, success criteria established, ready for implementation
diff --git a/specs/305-markdown-file-creation-fcf712/tasks.yaml b/specs/305-markdown-file-creation-fcf712/tasks.yaml
new file mode 100644
index 000000000..51782e693
--- /dev/null
+++ b/specs/305-markdown-file-creation-fcf712/tasks.yaml
@@ -0,0 +1,146 @@
+name: "markdown-file-creation-fcf712"
+summary: |
+  Three tasks across two sequential phases: (1) Create markdown file with H1 heading and prose content
+  using Python stdlib; (2) Validate file structure, encoding, and line endings;
+  (3) Execute git workflow (add, commit, push) to feature branch.
+  Estimated total: 10-15 minutes. No external dependencies or architectural changes required.
+
+relatedFeatures:
+  - 304
+  - 303
+  - 302
+  - 269
+
+technologies:
+  - "Python 3.x (standard library)"
+  - "Git CLI"
+
+relatedLinks:
+  - title: "CommonMark Specification"
+    url: "https://spec.commonmark.org/"
+  - title: "UTF-8 Encoding"
+    url: "https://en.wikipedia.org/wiki/UTF-8"
+
+tasks:
+  - id: task-1
+    phaseId: phase-1
+    title: "Create test-n33d8c.md with H1 heading and prose content"
+    description: |
+      Create markdown file at repository root with H1 heading on first line, blank line separator,
+      and 2-3 sentences of coherent prose. Use Python stdlib (pathlib/open) with UTF-8 encoding
+      and Unix LF line endings.
+    state: Todo
+    dependencies: []
+    acceptanceCriteria:
+      - "File test-n33d8c.md exists at repository root"
+      - "File begins with H1 markdown heading (# Title)"
+      - "Blank line separates heading from prose content"
+      - "File contains exactly 2-3 complete, grammatically correct sentences"
+      - "Prose content is coherent, meaningful, and appropriate"
+      - "File encoded as UTF-8 without BOM (verified with file command)"
+      - "File uses Unix LF line endings only (no CRLF)"
+      - "File size is naturally between 400-600 bytes"
+    tdd:
+      red:
+        - "Assert test-n33d8c.md does not exist"
+        - "Assert prose content requirements: 2-3 sentences, grammatically correct, meaningful"
+      green:
+        - "Use pathlib.Path or open() to create file"
+        - "Write H1 heading on first line: # Title"
+        - "Write blank line separator"
+        - "Write 2-3 sentences of coherent prose about any topic"
+        - "Ensure UTF-8 encoding via encoding='utf-8' parameter"
+      refactor:
+        - "Verify file encoding with: file -i test-n33d8c.md (should show UTF-8, no BOM)"
+        - "Verify line endings with: file test-n33d8c.md or od -c (should show LF only)"
+        - "Validate file is plain text, readable, and well-formed"
+    estimatedEffort: "5-7 min"
+
+  - id: task-2
+    phaseId: phase-1
+    title: "Validate file structure and encoding"
+    description: |
+      Verify test-n33d8c.md meets all specification requirements: correct structure,
+      encoding, line endings, and content validation.
+    state: Todo
+    dependencies:
+      - task-1
+    acceptanceCriteria:
+      - "File exists at exact path: ./test-n33d8c.md (repository root)"
+      - "H1 heading present on line 1"
+      - "Blank line present on line 2"
+      - "Prose content starts on line 3 with complete sentence"
+      - "File contains exactly 2-3 sentences (no more, no less)"
+      - "No trailing whitespace beyond final newline"
+      - "File encoding confirmed as UTF-8 without BOM"
+      - "File line endings confirmed as Unix LF"
+    tdd:
+      red:
+        - "Assert file structure: H1, blank line, prose on expected lines"
+        - "Assert file encoding: UTF-8 without BOM"
+        - "Assert line endings: LF only, no CRLF"
+        - "Assert sentence count: exactly 2-3 complete sentences"
+      green:
+        - "Read file and verify structure against requirements"
+        - "Use file -i test-n33d8c.md to confirm UTF-8 encoding"
+        - "Use od -c or similar to confirm LF line endings"
+        - "Count sentences in prose content"
+      refactor:
+        - "Document all validation checks performed"
+        - "Verify no edge cases (hidden characters, mixed line endings, etc.)"
+    estimatedEffort: "2-3 min"
+
+  - id: task-3
+    phaseId: phase-2
+    title: "Git workflow: stage, commit, and push"
+    description: |
+      Stage test-n33d8c.md with git add, create commit with conventional message format,
+      and push to feature branch with upstream tracking configured.
+    state: Todo
+    dependencies:
+      - task-2
+    acceptanceCriteria:
+      - "File is staged with git add test-n33d8c.md"
+      - "Commit created with message: \"feat(305): create markdown file test-n33d8c.md with prose content\""
+      - "Commit is on feature branch feat/305-markdown-file-creation-fcf712"
+      - "Commit is pushed to remote origin"
+      - "Upstream tracking configured (branch tracks origin/feat/305-...)"
+      - "No other files staged or committed"
+      - "Git status clean after push"
+    tdd:
+      red:
+        - "Assert file not in git index (git status shows untracked)"
+        - "Assert file not on remote feature branch"
+        - "Assert upstream tracking not configured"
+      green:
+        - "Execute: git add test-n33d8c.md"
+        - "Execute: git commit -m \"feat(305): create markdown file test-n33d8c.md with prose content\""
+        - "Execute: git push -u origin feat/305-markdown-file-creation-fcf712"
+      refactor:
+        - "Verify git status output: file staged, no changes pending"
+        - "Verify commit message matches conventional format exactly"
+        - "Verify upstream tracking: git branch -vv shows remote tracking"
+        - "Verify only test-n33d8c.md is in commit (no extraneous files)"
+    estimatedEffort: "2-3 min"
+
+totalEstimate: "10-15 min"
+openQuestions: []
+
+content: |
+  ## Summary
+
+  Three focused tasks across two sequential phases implement the feature:
+
+  **Phase 1: File Creation (7-10 minutes)**
+  - Task 1: Create test-n33d8c.md with H1 heading and 2-3 sentences of prose,
+    ensuring UTF-8 encoding and Unix LF line endings using Python stdlib
+  - Task 2: Validate file structure, encoding, line endings, and content requirements
+
+  **Phase 2: Git Workflow (3-5 minutes)**
+  - Task 3: Stage, commit (with conventional message), and push to remote feature branch
+
+  All tasks are sequential with dependencies enforced by task IDs.
+  No external dependencies, architectural changes, or testing infrastructure needed.
+  Implementation follows established pattern from 300+ prior markdown-file-creation features.
+
+  Total estimated time: 10-15 minutes (consistent with size estimate and prior features).
diff --git a/test-n33d8c.md b/test-n33d8c.md
new file mode 100644
index 000000000..349dd8196
--- /dev/null
+++ b/test-n33d8c.md
@@ -0,0 +1,3 @@
+# Advanced Distributed Systems
+
+Modern distributed systems face complex challenges in maintaining consistency and availability across multiple nodes and data centers. Building robust systems requires careful consideration of fault tolerance, network partitions, and eventual consistency models. Understanding these trade-offs enables engineers to architect systems that meet both performance and reliability requirements.