Merge pull request #3 from recursionlab/content/initial-pages

Merging seed content PR to publish About and Projects pages.

Author: recursionlab

.github/workflows/jekyll-build.yml

@@ -0,0 +1,33 @@
+name: Jekyll Build
+
+on:
+  pull_request:
+  push:
+    branches: [ main ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: '3.2'
+
+    - name: Install dependencies
+      run: |
+        gem install bundler
+        bundle config set --local path 'vendor/bundle'
+        bundle install --jobs 4 --retry 3
+
+    - name: Build site
+      run: bundle exec jekyll build --trace
+
+    - name: Upload site (artifact)
+      uses: actions/upload-artifact@v4
+      with:
+        name: site
+        path: _site

ARCHITECTURE.md

@@ -0,0 +1,30 @@
+# Architecture Notes — Recursion Lab
+
+This file distills a short Architect Guide for module authors who want to design and manage whole projects.
+
+Principles
+- Encapsulate intent: module boundaries should reflect responsibilities and invariants, not only file layout.
+- Standardize interfaces: use explicit, stable contracts (schemas or API specs).
+- Observability from the start: logs, traces, and metrics make integration problems visible.
+- Design for graceful failure: define how modules degrade and recover.
+- Evolve safely: version contracts and provide deprecation paths.
+
+Quick checklist
+- One-line ownership for each module (who owns what).
+- Explicit contract for each integration (inputs, outputs, errors).
+- Failure modes documented and practiced.
+- Integration tests in CI (contract tests and a small end-to-end smoke test).
+- Observability: structured logs + a couple of business metrics for key flows.
+
+Mini example (blog)
+- Content API owns canonical content and emits `content.updated` events.
+- Admin UI talks to Content API synchronously for editing flows.
+- Search service subscribes to events to index content asynchronously.
+- CDN serves static builds; preview mode reads content directly for staging.
+
+Practical next steps (minimal edits you can do now)
+- Add one-sentence ownership lines to module READMEs.
+- Add a contract checklist entry to PR templates (if you have them).
+- Ensure CI runs the Jekyll build (already present) and add a smoke test for a public route.
+
+If you want, I can convert this into a more detailed `ARCHITECTURE.md` with diagrams, or add a small PR template and a README checklist. For now this is kept minimal so you can add your content later.

README.md

@@ -177,3 +177,27 @@ The color schemes and fonts can also be customized through scss, by editing the
 
 - Base theme sparrow by [lingxz](https://github.com/lingxz/sparrow)
 - Icon made by [Freepik](https://www.freepik.com/) from www.flaticon.com 
+
+## Local development
+
+To preview the site locally you can use Bundler and Jekyll. From the repository root run:
+
+```bash
+# install gems
+bundle install
+
+# build the site and serve locally
+bundle exec jekyll serve --livereload
+```
+
+Open http://127.0.0.1:4000 in your browser to preview changes. When creating posts, add files to `_posts/` with a filename like `YYYY-MM-DD-title.md` and appropriate front matter.
+
+See `_qa/pagination-snippet.txt` for a quick build verification note I added earlier.
+
+### Drafts
+
+Place in-progress posts in the `_drafts/` folder (no date in filename). To preview drafts locally, run:
+
+```bash
+bundle exec jekyll serve --drafts --livereload
+```

_drafts/case-study-emergent-recursive-cognition.md

@@ -0,0 +1,16 @@
+---
+title: "Case Study: Emergent Recursive Cognition"
+author: Recursion Lab
+tags: [case-study, emergence]
+---
+
+Reported experiments (e.g., OnToLogic V1.0) where recursive loops produced unexpected behaviors.
+
+- What worked / what didn’t
+- Lessons and reproducible setups
+
+Draft notes:
+
+- Setup and assumptions
+- Observed behaviors and metrics
+- Failure analysis and iteration plan

_drafts/interface-mind-recursive-systems.md

@@ -0,0 +1,16 @@
+---
+title: "The Interface Between Mind and Recursive Systems"
+author: Recursion Lab
+tags: [cognition, systems, interaction]
+---
+
+How interacting with recursive AI/systems changes the way people think.
+
+- Cognitive reshaping, adaptation, feedback
+- Case references to discuss (e.g., observation effects)
+
+Draft notes:
+
+- Interaction patterns (what users see, how they adapt)
+- Risks (overtrust, loop amplification)
+- Design implications (affordances, transparency)

_drafts/recursive-reasoning-in-llms.md

@@ -0,0 +1,16 @@
+---
+title: "Recursive Reasoning in Language Models"
+author: Recursion Lab
+tags: [llm, recursion, prompting]
+---
+
+How LLMs currently do recursion (prompts, self-critique, looped tasks)
+
+- Pitfalls & limits (hallucinations, coherence collapse)
+- Best practices / experiments
+
+Draft notes:
+
+- Prompt patterns (plan → draft → critique → revise)
+- Tooling patterns (scratchpads, checklists, verifiers)
+- Metrics and failure cases

_drafts/what-is-symbolic-recursion.md

@@ -0,0 +1,17 @@
+---
+title: "What Is Symbolic Recursion and Why It Matters"
+author: Recursion Lab
+tags: [recursion, cognition, ai]
+---
+
+Define symbolic vs. syntactic recursion.
+
+- Examples from cognition, prompt engineering, and AI
+- Implications: self-reflection, emergent behavior, memory
+
+Draft notes:
+
+- Working definition(s)
+- Short examples (language, programs, representations)
+- Where it breaks or misleads
+- Open questions

_pages/projects.md

@@ -0,0 +1,29 @@
+---
+title: Projects
+layout: page
+permalink: /projects/
+---
+
+## Projects
+
+This page lists prototype ideas exploring recursive systems. Replace or expand these with your own projects as they evolve.
+
+### Recursive Self-Reflection Engine
+- Goal: Prototype a system that self-evaluates outputs, detects contradictions, and regenerates improved responses.
+- Sketch: Combine a language model with lightweight symbolic rules to create a feedback loop for critique → revise → verify.
+- Notes: Inspired by work on emergent recursive cognition via language-encoded symbolic systems. Add links and code when available.
+
+### Recursive Reasoning Tools for LLMs
+- Goal: Build tools or prompt frameworks that enforce recursive reasoning (multiple passes with critique and revision).
+- Sketch: Design a reusable protocol (plan → draft → critique → revise) and measure quality gains on target tasks.
+- Notes: Start with prompt-only approaches; evolve into lightweight libraries if useful.
+
+### Visualization of Feedback Systems
+- Goal: Create visual/interactive models of recursive systems from biology, cognition, or social domains.
+- Sketch: Show how loops amplify, stabilize, and collapse; let users tweak parameters to see phase changes.
+- Notes: Consider small web demos or notebooks.
+
+### Cognitive Architecture Comparisons
+- Goal: Compare architectures (e.g., CLARION and others) to locate where explicit vs. implicit recursion plays a role.
+- Sketch: Build small simulations to highlight differences in learning and control loops.
+- Notes: Collect references (papers, Wikipedia) and plan a minimal, comparable benchmark.

_posts/2025-09-14-welcome.md

@@ -0,0 +1,10 @@
+---
+title: "Welcome — Recursion Lab"
+date: 2025-09-14 09:00:00 +0000
+author: Recursion Lab
+tags: [welcome, meta]
+---
+
+This is the first post on Recursion Lab. Replace this content with your own writing, sketches, or notes. Posts live in the `_posts/` folder — their filename controls their published date and URL.
+
+Write in Markdown, set front matter variables (title, date, tags), and push to `main` or open a PR.

about.md

@@ -1,6 +1,23 @@
 ---
 title: About
 layout: page
+permalink: /about/
+---
+
+## About
+
+Recursion Lab studies the interplay of recursion, cognition, and systems. We publish public notes and working prototypes that test ideas about feedback, self‑reference, and emergent behavior.
+
+We believe recursion is a core mechanism — in learning, in feedback, and in self‑reference. Through notes, experiments, and open-source prototypes we explore:
+
+- How recursive architectures enable emergent cognition
+- How biological, computational, and social systems stabilize via feedback loops
+- What happens when recursion is applied to meaning, memory, and identity
+
+This site is a research‑and‑prototype space. Browse the Blog for ongoing notes, and Projects for experiments you can try. Replace this paragraph with your contact or newsletter link when ready.
+---
+title: About
+layout: page
 ---
 
 ## About