diff --git a/CONTENT_BRIDGE.md b/CONTENT_BRIDGE.md
new file mode 100644
index 0000000..b5374cd
--- /dev/null
+++ b/CONTENT_BRIDGE.md
@@ -0,0 +1,166 @@
+# Blog Content Bridge
+
+The public Obsidian vault is the writing source of truth. The Astro sites are
+deployable targets that receive copied Markdown and assets.
+
+## Folder Map
+
+| Vault folder           | Astro content folder                        | Public domain                        |
+| ---------------------- | ------------------------------------------- | ------------------------------------ |
+| `blogs/01-research`    | `sites/research/src/content/research`       | `https://research.neeldhara.blog`    |
+| `blogs/02-vibes`       | `sites/vibes/src/content/vibes`             | `https://vibes.neeldhara.blog`       |
+| `blogs/03-puzzles`     | `sites/puzzles/src/content/puzzles`         | `https://puzzles.neeldhara.blog`     |
+| `blogs/04-reflections` | `sites/reflections/src/content/reflections` | `https://reflections.neeldhara.blog` |
+| `blogs/05-poetry`      | `sites/poetry/src/content/poetry`           | `https://poetry.neeldhara.blog`      |
+| `blogs/06-reviews`     | `sites/reviews/src/content/reviews`         | `https://reviews.neeldhara.blog`     |
+| `blogs/07-art`         | `sites/art/src/content/art`                 | `https://art.neeldhara.blog`         |
+| `blogs/micro`          | `../micro/src/content/blog`                 | `https://micro.neeldhara.blog`       |
+
+The installed Obsidian plugin lives at:
+
+```text
+/Users/neeldhara/obsidian/public/.obsidian/plugins/microblog-sync
+```
+
+The versioned copy lives in this repo at:
+
+```text
+obsidian-plugin/microblog-sync
+```
+
+The plugin id remains `microblog-sync`, but Obsidian shows it as **Blog Family
+Sync**.
+
+## Post Layout
+
+Use one folder per post:
+
+```text
+blogs/01-research/example-post/index.md
+blogs/01-research/example-post/diagram.png
+```
+
+The folder path becomes the public URL:
+
+```text
+blogs/01-research/example-post/index.md
+https://research.neeldhara.blog/example-post/
+```
+
+Nested folders are supported:
+
+```text
+blogs/04-reflections/exportober/2021/index.md
+https://reflections.neeldhara.blog/exportober/2021/
+```
+
+## Frontmatter
+
+Every public post needs the fields required by the Astro content schema:
+
+```yaml
+---
+title: "Post title"
+description: "One or two sentence summary for cards and RSS."
+pubDate: "2024-05-10"
+authorName: "Neeldhara"
+---
+```
+
+Optional fields currently understood by the sites include `updatedDate`,
+`image`, and `authorImage`. Prefer colocated images in the body over remote
+stock images.
+
+The Quarto import also preserved `sourceCategories` and `sourcePath`. Astro
+strips unknown schema fields, but they are useful in Obsidian for provenance.
+
+## Markdown Conventions
+
+Standard Markdown headings, lists, links, tables, code fences, footnotes, and
+raw HTML are preserved.
+
+Use colocated relative assets:
+
+```markdown
+![Caption](image.png)
+```
+
+Quarto image attributes such as `{width=70%}` were removed during import. Going
+forward, use normal Markdown and let Astro CSS handle presentation.
+
+Quarto callouts were converted to portable blockquotes:
+
+```markdown
+> **Note**
+>
+> Text of the callout.
+```
+
+Use the same convention for new notes:
+
+```markdown
+> **Warning**
+>
+> This point needs attention.
+```
+
+Quarto margin notes such as `[text]{.aside}` were converted to:
+
+```markdown
+> **Aside:** text
+```
+
+## Import Rules
+
+The import script is:
+
+```text
+scripts/import-quarto-blog.mjs
+```
+
+It reads the Quarto archive, skips `draft: true`, converts `index.qmd` to
+`index.md`, copies colocated assets, and writes a temporary tree under
+`/private/tmp/quarto-blog-import`.
+
+The first import made these category choices:
+
+| Blog          | Rule of thumb                                                      |
+| ------------- | ------------------------------------------------------------------ |
+| `research`    | CS/math exposition, lecture notes, and academic explainers.        |
+| `vibes`       | LLM-assisted making, interactives, and generated-tool experiments. |
+| `puzzles`     | Puzzle/game/problem posts.                                         |
+| `reflections` | Essays, speeches, teaching/career notes, and Exportober context.   |
+| `poetry`      | Poems.                                                             |
+| `reviews`     | Tool, workflow, software, website, book-list, and tutorial posts.  |
+| `art`         | Visual/sketchnote/design/communications-oriented posts.            |
+
+See `IMPORT_REPORT.md` for the specific source-to-destination mapping.
+
+## Sync Rules
+
+- Obsidian is the source of truth for day-to-day writing.
+- Auto-sync copies changes from the matching `blogs/...` folder into the
+  matching local Astro content folder.
+- The plugin includes Markdown plus common web assets: images, PDFs,
+  JSON/YAML, JS, CSS, HTML, and text files.
+- One-way sync does not delete target files unless **Delete orphaned target
+  files** is enabled.
+- The initial Quarto import used replace-style sync to clear placeholder Astro
+  posts. Day-to-day editing should use the plugin.
+
+## Preview And Publish
+
+Use these Obsidian commands:
+
+- `Blog Family Sync: Sync and preview current note`
+- `Blog Family Sync: Publish current note`
+- `Blog Family Sync: Publish all changes for current blog`
+
+Preview detects the current note's folder, starts the matching Astro dev server
+on its configured local port, and opens the post URL.
+
+Publish does three things:
+
+1. Sync vault content into the local repo.
+2. Run the configured Astro build command.
+3. Commit and push to Forgejo, where Dokploy picks up the change.
diff --git a/IMPORT_REPORT.md b/IMPORT_REPORT.md
new file mode 100644
index 0000000..e0c79d5
--- /dev/null
+++ b/IMPORT_REPORT.md
@@ -0,0 +1,63 @@
+# Quarto Blog Import Report
+
+Source: /private/tmp/quartosite-shallow/blog
+Generated: 2026-06-20T01:03:56.508Z
+
+## Imported Posts
+
+| Blog        | Date       | Title                                       | Source                                        | Destination                                               |
+| ----------- | ---------- | ------------------------------------------- | --------------------------------------------- | --------------------------------------------------------- |
+| art         | 2024-05-10 | Creating a Gallery of Solved Crosswords     | `indiamini-crosswords/index.qmd`              | `07-art/indiamini-crosswords/index.md`                    |
+| art         | 2022-09-23 | External Communications                     | `comms/index.qmd`                             | `07-art/comms/index.md`                                   |
+| art         | 2021-10-04 | On the Communication Complexity of Equality | `communication-complexity-equality/index.qmd` | `07-art/communication-complexity-equality/index.md`       |
+| poetry      | 2024-01-13 | Winning                                     | `poems/winning/index.qmd`                     | `05-poetry/poems/winning/index.md`                        |
+| poetry      | 2024-01-01 | Poetry                                      | `poems/poetry/index.qmd`                      | `05-poetry/poems/poetry/index.md`                         |
+| poetry      | 2023-05-11 | Letting Go                                  | `poems/letting-go/index.qmd`                  | `05-poetry/poems/letting-go/index.md`                     |
+| poetry      | 2012-08-27 | Dad                                         | `poems/dad/index.qmd`                         | `05-poetry/poems/dad/index.md`                            |
+| poetry      | 2012-04-23 | On the Fence                                | `poems/on-the-fence/index.qmd`                | `05-poetry/poems/on-the-fence/index.md`                   |
+| poetry      | 2011-01-05 | Sprinkles of the Sky                        | `poems/sprinkles-of-the-sky/index.qmd`        | `05-poetry/poems/sprinkles-of-the-sky/index.md`           |
+| poetry      | 2007-04-03 | Seek                                        | `poems/seek/index.qmd`                        | `05-poetry/poems/seek/index.md`                           |
+| poetry      | 2005-02-03 | Bloom                                       | `poems/bloom/index.qmd`                       | `05-poetry/poems/bloom/index.md`                          |
+| puzzles     | 2022-09-19 | Dog Bunny Puzzle                            | `dogs-bunny-puzzle/index.qmd`                 | `03-puzzles/dogs-bunny-puzzle/index.md`                   |
+| puzzles     | 2022-03-24 | Solo Chess                                  | `solo-chess/index.qmd`                        | `03-puzzles/solo-chess/index.md`                          |
+| puzzles     | 2021-10-03 | Two approaches to the 15 puzzle             | `15-puzzle/index.qmd`                         | `03-puzzles/15-puzzle/index.md`                           |
+| puzzles     | 2021-09-21 | Moving Blocks at CTIS 2021                  | `moving-blocks-ctis/index.qmd`                | `03-puzzles/moving-blocks-ctis/index.md`                  |
+| reflections | 2023-05-26 | On Career Choices                           | `on-career-choices/index.qmd`                 | `04-reflections/on-career-choices/index.md`               |
+| reflections | 2022-11-24 | The Only Fair Ranking of IITs               | `iit-rankings/index.qmd`                      | `04-reflections/iit-rankings/index.md`                    |
+| reflections | 2022-10-07 | Exportober 2022                             | `exportober/2022-tracker/index.qmd`           | `04-reflections/exportober/2022-tracker/index.md`         |
+| reflections | 2022-09-23 | SKJ                                         | `skj/index.qmd`                               | `04-reflections/skj/index.md`                             |
+| reflections | 2022-09-05 | On Teaching                                 | `on-teaching/index.qmd`                       | `04-reflections/on-teaching/index.md`                     |
+| reflections | 2022-03-15 | Eight Self-Sabotaging Behaviors             | `eight-self-sabotaging-behaviors/index.qmd`   | `04-reflections/eight-self-sabotaging-behaviors/index.md` |
+| reflections | 2021-09-25 | Exportober 2021                             | `exportober/2021-tracker/index.qmd`           | `04-reflections/exportober/2021-tracker/index.md`         |
+| reflections | 2021-09-24 | About Exportober                            | `exportober/about/index.qmd`                  | `04-reflections/exportober/about/index.md`                |
+| reflections | 2021-09-19 | An Invitation to Exportober 2021            | `exportober/2021/index.qmd`                   | `04-reflections/exportober/2021/index.md`                 |
+| research    | 2023-12-21 | Intro to Crypto                             | `crypto-intro/index.qmd`                      | `01-research/crypto-intro/index.md`                       |
+| research    | 2022-02-25 | Kidney Exchanges                            | `kidney-exchanges/index.qmd`                  | `01-research/kidney-exchanges/index.md`                   |
+| research    | 2021-10-01 | Sam I Am                                    | `cp/sam-i-am/index.qmd`                       | `01-research/cp/sam-i-am/index.md`                        |
+| research    | 2010-05-01 | How Expensive Can Homework Help Be?         | `homework-help/index.qmd`                     | `01-research/homework-help/index.md`                      |
+| reviews     | 2023-10-01 | Exportober 2023                             | `2023-exportober-workflows/index.qmd`         | `06-reviews/2023-exportober-workflows/index.md`           |
+| reviews     | 2023-06-02 | Note Taking Resources                       | `note-taking-resources/index.qmd`             | `06-reviews/note-taking-resources/index.md`               |
+| reviews     | 2022-11-27 | Letters with Pandoc                         | `pandoc-letters/index.qmd`                    | `06-reviews/pandoc-letters/index.md`                      |
+| reviews     | 2022-02-21 | Women in Mathematics                        | `women-in-mathematics/index.qmd`              | `06-reviews/women-in-mathematics/index.md`                |
+| reviews     | 2021-09-30 | New Mac                                     | `new-mac/index.qmd`                           | `06-reviews/new-mac/index.md`                             |
+| reviews     | 2021-09-18 | Envelope Budgeting with Notion              | `envelope-budgeting-notion/index.qmd`         | `06-reviews/envelope-budgeting-notion/index.md`           |
+| reviews     | 2021-09-12 | Actually Building a Website with Notion     | `building-websites-with-notion/index.qmd`     | `06-reviews/building-websites-with-notion/index.md`       |
+| reviews     | 2021-09-11 | Notion-powered websites                     | `notion-powered-websites/index.qmd`           | `06-reviews/notion-powered-websites/index.md`             |
+| reviews     | 2020-09-11 | Massren for fast file renaming              | `massren/index.qmd`                           | `06-reviews/massren/index.md`                             |
+| reviews     | 2018-06-12 | Building a first Django App                 | `django-app/index.qmd`                        | `06-reviews/django-app/index.md`                          |
+| vibes       | 2023-12-25 | Course Plan Generator                       | `course-plan/2024-fall/index.qmd`             | `02-vibes/course-plan/2024-fall/index.md`                 |
+| vibes       | 2023-12-25 | Course Plan Generator                       | `course-plan/2024-spring/index.qmd`           | `02-vibes/course-plan/2024-spring/index.md`               |
+| vibes       | 2023-07-30 | Building Interactives                       | `building-interactives/index.qmd`             | `02-vibes/building-interactives/index.md`                 |
+| vibes       | 2023-04-25 | Course Plan Generator                       | `course-plan/index.qmd`                       | `02-vibes/course-plan/index.md`                           |
+| vibes       | 2023-03-26 | 13 Sheep                                    | `13sheep/index.qmd`                           | `02-vibes/13sheep/index.md`                               |
+
+## Skipped Drafts
+
+- `b-matching-games/index.qmd`
+- `degree-width/index.qmd`
+- `math-of-juggling/index.qmd`
+- `refute-questions/index.qmd`
+- `secret-interactive-proofs/index.qmd`
+- `twitter/index.qmd`
+- `weightmodification/index.qmd`
+- `woce/collective-welfare/index.qmd`
diff --git a/README.md b/README.md
index 8370c9b..1bed87a 100644
--- a/README.md
+++ b/README.md
@@ -49,3 +49,10 @@ npm run build --prefix sites/research
 ## Deploy
 
 Deployment is via Forgejo + Dokploy. See [DEPLOYMENT.md](./DEPLOYMENT.md).
+
+## Obsidian Content Bridge
+
+The seven blog content folders are synced from the public Obsidian vault. See
+[CONTENT_BRIDGE.md](./CONTENT_BRIDGE.md) for conventions, preview/publish
+commands, and the Quarto import workflow. See [IMPORT_REPORT.md](./IMPORT_REPORT.md)
+for the current imported post mapping.
diff --git a/obsidian-plugin/microblog-sync/README.md b/obsidian-plugin/microblog-sync/README.md
new file mode 100644
index 0000000..5381e49
--- /dev/null
+++ b/obsidian-plugin/microblog-sync/README.md
@@ -0,0 +1,46 @@
+# Blog Family Sync
+
+This local Obsidian plugin syncs the public vault blog folders with the local
+Astro sites under `/Users/neeldhara/forgejo/blogs`.
+
+The plugin id remains `microblog-sync` so the existing Obsidian installation can
+be upgraded in place. In Obsidian, the visible plugin name is **Blog Family
+Sync**.
+
+## Targets
+
+| Vault folder           | Local content folder                                 | Preview                          |
+| ---------------------- | ---------------------------------------------------- | -------------------------------- |
+| `blogs/micro`          | `micro/src/content/blog`                             | `http://127.0.0.1:4321/blog/...` |
+| `blogs/01-research`    | `allblogs/sites/research/src/content/research`       | `http://127.0.0.1:4331/...`      |
+| `blogs/02-vibes`       | `allblogs/sites/vibes/src/content/vibes`             | `http://127.0.0.1:4332/...`      |
+| `blogs/03-puzzles`     | `allblogs/sites/puzzles/src/content/puzzles`         | `http://127.0.0.1:4333/...`      |
+| `blogs/04-reflections` | `allblogs/sites/reflections/src/content/reflections` | `http://127.0.0.1:4334/...`      |
+| `blogs/05-poetry`      | `allblogs/sites/poetry/src/content/poetry`           | `http://127.0.0.1:4335/...`      |
+| `blogs/06-reviews`     | `allblogs/sites/reviews/src/content/reviews`         | `http://127.0.0.1:4336/...`      |
+| `blogs/07-art`         | `allblogs/sites/art/src/content/art`                 | `http://127.0.0.1:4337/...`      |
+
+## Commands
+
+Search for **Blog Family Sync** in the command palette:
+
+- `Sync all configured blogs`
+- `Sync current blog vault folder to repo`
+- `Sync current blog repo folder to vault`
+- `Two-way sync current blog`
+- `Sync and preview current note`
+- `Publish current note`
+- `Publish all changes for current blog`
+
+Preview starts the matching Astro dev server if the configured local URL is not
+already responding. Publish syncs first, runs that target's build command,
+commits staged content changes, and pushes to Forgejo.
+
+## Notes
+
+- Obsidian is the source of truth for day-to-day writing.
+- Deletions are not mirrored unless `Delete orphaned target files` is enabled.
+- The plugin watches all configured vault folders and also polls for external
+  edits, which catches changes made by another editor.
+- Debug output is written to
+  `.obsidian/plugins/microblog-sync/debug.log`.
diff --git a/obsidian-plugin/microblog-sync/main.js b/obsidian-plugin/microblog-sync/main.js
new file mode 100644
index 0000000..20b4f58
--- /dev/null
+++ b/obsidian-plugin/microblog-sync/main.js
@@ -0,0 +1,1575 @@
+const { Notice, Plugin, PluginSettingTab, Setting } = require("obsidian");
+const { spawn } = require("child_process");
+const fs = require("fs/promises");
+const nodeFs = require("fs");
+const http = require("http");
+const https = require("https");
+const path = require("path");
+
+const NODE_BIN = "/Users/neeldhara/.nvm/versions/node/v22.22.0/bin";
+const NPM = `${NODE_BIN}/npm`;
+const BLOGS_ROOT = "/Users/neeldhara/forgejo/blogs";
+const ALLBLOGS_REPO = `${BLOGS_ROOT}/allblogs`;
+const MICRO_REPO = `${BLOGS_ROOT}/micro`;
+
+const DEFAULT_TARGETS = [
+  {
+    id: "micro",
+    label: "Micro",
+    vaultFolder: "blogs/micro",
+    repoFolder: MICRO_REPO,
+    appFolder: MICRO_REPO,
+    contentFolder: `${MICRO_REPO}/src/content/blog`,
+    previewPathPrefix: "/blog",
+    devServerUrl: "http://127.0.0.1:4321",
+    devServerCommand: `${NPM} run dev -- --host 127.0.0.1 --port 4321 --strictPort`,
+    publishBuildCommand: `${NPM} run build`,
+    publishCommitMessage: "Publish microblog updates",
+    stageAllPaths: ["src/content/blog", "public/_redirects"],
+    extraCurrentStagePaths: ["public/_redirects"],
+  },
+  blogTarget("research", "Research", "01-research", 4331),
+  blogTarget("vibes", "Vibes", "02-vibes", 4332),
+  blogTarget("puzzles", "Puzzles", "03-puzzles", 4333),
+  blogTarget("reflections", "Reflections", "04-reflections", 4334),
+  blogTarget("poetry", "Poetry", "05-poetry", 4335),
+  blogTarget("reviews", "Reviews", "06-reviews", 4336),
+  blogTarget("art", "Art", "07-art", 4337),
+];
+
+const DEFAULT_SETTINGS = {
+  syncDirection: "vault-to-repo",
+  autoSyncOnChange: true,
+  watchFilesystemChanges: true,
+  pollForExternalChanges: true,
+  pollIntervalMs: 3000,
+  syncOnStartup: true,
+  showStatusBar: true,
+  ignoreDraftMarkdown: true,
+  deleteOrphans: false,
+  debounceMs: 1000,
+  includeExtensions:
+    "md,mdx,jpg,jpeg,png,gif,webp,svg,pdf,js,json,yml,yaml,css,html,txt",
+  devServerShell: "/bin/zsh",
+  commandPathPrepend: `${NODE_BIN}:/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin`,
+  devServerReadyTimeoutMs: 15000,
+  openPreviewEvenIfServerStartFails: false,
+  debugLogPath: ".obsidian/plugins/microblog-sync/debug.log",
+  targets: DEFAULT_TARGETS,
+};
+
+const MARKDOWN_EXTENSIONS = new Set([".md", ".mdx"]);
+
+module.exports = class BlogFamilySyncPlugin extends Plugin {
+  async onload() {
+    await this.loadSettings();
+    this.isSyncing = false;
+    this.debounceTimers = new Map();
+    this.pollIntervalId = null;
+    this.fileWatchers = [];
+    this.devServers = new Map();
+    this.lastVaultSnapshot = null;
+    this.statusBar = this.addStatusBarItem();
+    this.updateStatusBar("Blog sync: idle");
+
+    this.addRibbonIcon("refresh-cw", "Sync all blog content", () => {
+      this.syncWithNotice(this.settings.syncDirection);
+    });
+
+    this.addRibbonIcon(
+      "external-link",
+      "Sync and preview current blog note",
+      () => {
+        this.syncAndPreviewCurrentNote();
+      },
+    );
+
+    this.addCommand({
+      id: "blog-family-sync-all",
+      name: "Sync all configured blogs",
+      callback: () => this.syncWithNotice(this.settings.syncDirection),
+    });
+
+    this.addCommand({
+      id: "blog-family-sync-current-vault-to-repo",
+      name: "Sync current blog vault folder to repo",
+      callback: () => this.syncCurrentTargetWithNotice("vault-to-repo"),
+    });
+
+    this.addCommand({
+      id: "blog-family-sync-current-repo-to-vault",
+      name: "Sync current blog repo folder to vault",
+      callback: () => this.syncCurrentTargetWithNotice("repo-to-vault"),
+    });
+
+    this.addCommand({
+      id: "blog-family-sync-current-two-way",
+      name: "Two-way sync current blog",
+      callback: () => this.syncCurrentTargetWithNotice("two-way"),
+    });
+
+    this.addCommand({
+      id: "blog-family-preview-current",
+      name: "Sync and preview current note",
+      callback: () => this.syncAndPreviewCurrentNote(),
+    });
+
+    this.addCommand({
+      id: "blog-family-publish-current-note",
+      name: "Publish current note",
+      callback: () => this.publishCurrentNote(),
+    });
+
+    this.addCommand({
+      id: "blog-family-publish-current-blog",
+      name: "Publish all changes for current blog",
+      callback: () => this.publishCurrentBlog(),
+    });
+
+    this.registerEvent(
+      this.app.vault.on("create", (file) => this.scheduleAutoSync(file)),
+    );
+    this.registerEvent(
+      this.app.vault.on("modify", (file) => this.scheduleAutoSync(file)),
+    );
+    this.registerEvent(
+      this.app.vault.on("delete", (file) => this.scheduleAutoSync(file)),
+    );
+    this.registerEvent(
+      this.app.vault.on("rename", (file, oldPath) =>
+        this.scheduleAutoSync(file, oldPath),
+      ),
+    );
+
+    this.addSettingTab(new BlogFamilySyncSettingTab(this.app, this));
+
+    await this.resetPollSnapshot();
+    this.startPolling();
+    this.startFileWatchers();
+
+    if (this.settings.syncOnStartup) {
+      await this.syncWithNotice(this.settings.syncDirection, true);
+      await this.resetPollSnapshot();
+    }
+  }
+
+  onunload() {
+    for (const timer of this.debounceTimers.values()) {
+      window.clearTimeout(timer);
+    }
+    this.debounceTimers.clear();
+
+    if (this.pollIntervalId) {
+      window.clearInterval(this.pollIntervalId);
+    }
+
+    for (const watcher of this.fileWatchers) {
+      watcher.close();
+    }
+    this.fileWatchers = [];
+
+    for (const state of this.devServers.values()) {
+      if (state.process && !state.process.killed) {
+        state.process.kill();
+      }
+    }
+    this.devServers.clear();
+  }
+
+  async loadSettings() {
+    const saved = await this.loadData();
+    this.settings = Object.assign({}, DEFAULT_SETTINGS, saved || {});
+
+    if (
+      !Array.isArray(this.settings.targets) ||
+      !this.settings.targets.length
+    ) {
+      this.settings.targets = DEFAULT_TARGETS;
+    }
+
+    if (
+      !this.settings.includeExtensions ||
+      this.settings.includeExtensions === "md,mdx,jpg,jpeg,png,gif,webp,svg"
+    ) {
+      this.settings.includeExtensions = DEFAULT_SETTINGS.includeExtensions;
+    }
+
+    this.settings.syncDirection = normalizeDirection(
+      this.settings.syncDirection,
+    );
+  }
+
+  async saveSettings() {
+    await this.saveData(this.settings);
+  }
+
+  getTargets() {
+    return this.settings.targets.map((target) => normalizeTarget(target));
+  }
+
+  getTargetById(targetId) {
+    return this.getTargets().find((target) => target.id === targetId);
+  }
+
+  getCurrentTarget() {
+    const activePath = this.getActiveFilePath();
+    const target = this.getTargetForVaultPath(activePath);
+    if (!target) {
+      throw new Error(
+        "Open a Markdown note under one of the configured blog folders first.",
+      );
+    }
+
+    return target;
+  }
+
+  getTargetForVaultPath(filePath) {
+    if (!filePath) {
+      return null;
+    }
+
+    const normalized = normalizeRelativePath(filePath);
+    return (
+      this.getTargets().find((target) => {
+        const folder = normalizeRelativePath(target.vaultFolder);
+        return normalized === folder || normalized.startsWith(`${folder}/`);
+      }) || null
+    );
+  }
+
+  startPolling() {
+    if (this.pollIntervalId) {
+      window.clearInterval(this.pollIntervalId);
+      this.pollIntervalId = null;
+    }
+
+    if (
+      !this.settings.autoSyncOnChange ||
+      !this.settings.pollForExternalChanges
+    ) {
+      return;
+    }
+
+    const intervalMs = Math.max(
+      1000,
+      Number(this.settings.pollIntervalMs) || DEFAULT_SETTINGS.pollIntervalMs,
+    );
+    this.pollIntervalId = window.setInterval(() => {
+      this.pollVaultFolders();
+    }, intervalMs);
+    this.registerInterval(this.pollIntervalId);
+  }
+
+  startFileWatchers() {
+    for (const watcher of this.fileWatchers) {
+      watcher.close();
+    }
+    this.fileWatchers = [];
+
+    if (
+      !this.settings.autoSyncOnChange ||
+      !this.settings.watchFilesystemChanges
+    ) {
+      return;
+    }
+
+    const vaultRoot = this.getVaultRoot();
+    const extensions = getIncludedExtensions(this.settings.includeExtensions);
+
+    for (const target of this.getTargets()) {
+      try {
+        const vaultFolder = path.resolve(vaultRoot, target.vaultFolder);
+        const watcher = nodeFs.watch(
+          vaultFolder,
+          { recursive: true },
+          (_eventType, filename) => {
+            if (!filename) {
+              this.scheduleSync(target.id, true);
+              return;
+            }
+
+            const relativePath = toPosix(String(filename));
+            if (isHiddenPath(relativePath)) {
+              return;
+            }
+
+            const ext = path.extname(relativePath).toLowerCase();
+            if (extensions.has(ext)) {
+              this.scheduleSync(target.id, true);
+            }
+          },
+        );
+
+        watcher.on("error", (error) => {
+          console.warn(
+            `Blog sync filesystem watcher failed for ${target.id}; polling remains active.`,
+            error,
+          );
+        });
+        this.fileWatchers.push(watcher);
+      } catch (error) {
+        console.warn(
+          `Blog sync could not start filesystem watcher for ${target.id}; polling remains active.`,
+          error,
+        );
+      }
+    }
+  }
+
+  async restartWatchers() {
+    await this.resetPollSnapshot();
+    this.startPolling();
+    this.startFileWatchers();
+  }
+
+  async resetPollSnapshot() {
+    try {
+      this.lastVaultSnapshot = await this.buildVaultSnapshot();
+    } catch (error) {
+      console.warn("Blog sync could not initialize folder polling", error);
+      this.lastVaultSnapshot = null;
+    }
+  }
+
+  async pollVaultFolders() {
+    if (
+      this.isSyncing ||
+      !this.settings.autoSyncOnChange ||
+      !this.settings.pollForExternalChanges
+    ) {
+      return;
+    }
+
+    try {
+      const snapshot = await this.buildVaultSnapshot();
+      if (this.lastVaultSnapshot === null) {
+        this.lastVaultSnapshot = snapshot;
+        return;
+      }
+
+      if (snapshot !== this.lastVaultSnapshot) {
+        this.lastVaultSnapshot = snapshot;
+        await this.syncWithNotice(this.settings.syncDirection, true);
+        this.lastVaultSnapshot = await this.buildVaultSnapshot();
+      }
+    } catch (error) {
+      console.error("Blog sync polling failed", error);
+    }
+  }
+
+  async buildVaultSnapshot() {
+    const vaultRoot = this.getVaultRoot();
+    const extensions = getIncludedExtensions(this.settings.includeExtensions);
+    const parts = [];
+
+    for (const target of this.getTargets()) {
+      const vaultFolder = path.resolve(vaultRoot, target.vaultFolder);
+      const entries = await collectFiles(
+        vaultFolder,
+        extensions,
+        "vault",
+        this.settings.ignoreDraftMarkdown,
+      );
+      const snapshot = [...entries.values()]
+        .sort((left, right) =>
+          left.logicalPath.localeCompare(right.logicalPath),
+        )
+        .map(
+          (entry) =>
+            `${target.id}:${entry.logicalPath}:${Math.round(entry.mtimeMs)}:${entry.size}`,
+        )
+        .join("\n");
+      parts.push(snapshot);
+    }
+
+    return parts.join("\n");
+  }
+
+  scheduleAutoSync(file, oldPath) {
+    if (!this.settings.autoSyncOnChange || this.isSyncing) {
+      return;
+    }
+
+    const target =
+      this.getTargetForVaultPath(file?.path) ||
+      this.getTargetForVaultPath(oldPath);
+    if (!target) {
+      return;
+    }
+
+    this.scheduleSync(target.id, true);
+  }
+
+  scheduleSync(targetId, quiet = true) {
+    if (!this.settings.autoSyncOnChange || this.isSyncing) {
+      return;
+    }
+
+    if (this.debounceTimers.has(targetId)) {
+      window.clearTimeout(this.debounceTimers.get(targetId));
+    }
+
+    const timer = window.setTimeout(() => {
+      const target = this.getTargetById(targetId);
+      if (target) {
+        this.syncWithNotice(this.settings.syncDirection, quiet, target);
+      }
+      this.debounceTimers.delete(targetId);
+    }, this.settings.debounceMs);
+
+    this.debounceTimers.set(targetId, timer);
+  }
+
+  async syncCurrentTargetWithNotice(direction) {
+    const target = this.getCurrentTarget();
+    await this.syncWithNotice(direction, false, target);
+  }
+
+  async syncWithNotice(direction, quiet = false, target = null) {
+    const normalizedDirection = normalizeDirection(direction);
+    try {
+      const label = target ? target.label : "all blogs";
+      this.updateStatusBar(`Blog sync: syncing ${label}...`);
+      const result = await this.sync(normalizedDirection, target);
+      const message = `Blog sync complete (${label}): ${result.copied} copied, ${result.deleted} deleted, ${result.skipped} unchanged.`;
+      console.info(message, result);
+      this.updateStatusBar(
+        `Blog sync: ${result.copied} copied, ${result.skipped} unchanged`,
+      );
+      await this.resetPollSnapshot();
+      if (!quiet) {
+        new Notice(message);
+      }
+    } catch (error) {
+      console.error("Blog sync failed", error);
+      this.updateStatusBar("Blog sync: failed");
+      new Notice(`Blog sync failed: ${error.message}`);
+    }
+  }
+
+  updateStatusBar(message) {
+    if (!this.statusBar) {
+      return;
+    }
+
+    if (!this.settings.showStatusBar) {
+      this.statusBar.setText("");
+      return;
+    }
+
+    this.statusBar.setText(message);
+  }
+
+  async syncAndPreviewCurrentNote() {
+    try {
+      const activePath = this.getActiveFilePath();
+      const target = this.getCurrentTarget();
+      const url = this.getPreviewUrl(activePath, target);
+      await this.logDebug(
+        `Preview requested for ${target.id}:${activePath} -> ${url}`,
+      );
+      this.updateStatusBar(`Blog sync: syncing ${target.label} for preview...`);
+      await this.sync("vault-to-repo", target);
+      await this.resetPollSnapshot();
+      this.updateStatusBar(`Blog sync: starting ${target.label} dev server...`);
+      try {
+        await this.ensureDevServer(target);
+      } catch (error) {
+        await this.logDebug(
+          `Dev server failed for ${target.id}: ${error.stack || error.message}`,
+        );
+        if (!this.settings.openPreviewEvenIfServerStartFails) {
+          throw error;
+        }
+      }
+      await openExternalUrl(url);
+      await this.logDebug(`Opened preview URL: ${url}`);
+      this.updateStatusBar("Blog sync: preview opened");
+      new Notice(`Opened preview: ${url}`);
+    } catch (error) {
+      console.error("Blog preview failed", error);
+      await this.logDebug(`Preview failed: ${error.stack || error.message}`);
+      this.updateStatusBar("Blog sync: preview failed");
+      new Notice(
+        `Blog preview failed: ${error.message}. See ${this.getDebugLogPath()}`,
+      );
+    }
+  }
+
+  async publishCurrentNote() {
+    try {
+      const activePath = this.getActiveFilePath();
+      const target = this.getCurrentTarget();
+      const slug = this.getSlugForVaultPath(activePath, target);
+      if (!slug) {
+        throw new Error(
+          "Open a Markdown note under one of the configured blog folders first.",
+        );
+      }
+
+      const contentRelativePath = this.getContentRepoPath(activePath, target);
+      const paths = [
+        contentRelativePath,
+        ...(target.extraCurrentStagePaths || []),
+      ];
+      const message = `${target.publishCommitMessage}: ${slug}`;
+      await this.publish(target, paths, message);
+    } catch (error) {
+      console.error("Blog publish current note failed", error);
+      this.updateStatusBar("Blog sync: publish failed");
+      new Notice(`Blog publish failed: ${error.message}`);
+    }
+  }
+
+  async publishCurrentBlog() {
+    try {
+      const target = this.getCurrentTarget();
+      const paths = target.stageAllPaths || [
+        toPosix(path.relative(target.repoFolder, target.contentFolder)),
+      ];
+      await this.publish(target, paths, target.publishCommitMessage);
+    } catch (error) {
+      console.error("Blog publish failed", error);
+      this.updateStatusBar("Blog sync: publish failed");
+      new Notice(`Blog publish failed: ${error.message}`);
+    }
+  }
+
+  async publish(target, pathsToStage, commitMessage) {
+    this.updateStatusBar(
+      `Blog sync: syncing ${target.label} before publish...`,
+    );
+    await this.sync("vault-to-repo", target);
+    await this.resetPollSnapshot();
+
+    const repoFolder = path.resolve(target.repoFolder);
+    const buildCommand = target.publishBuildCommand;
+    this.updateStatusBar(`Blog sync: building ${target.label}...`);
+    await this.runShellCommand(buildCommand, repoFolder);
+
+    const addTargets = [...new Set(pathsToStage)].map(shellQuote).join(" ");
+    const commit = shellQuote(commitMessage || target.publishCommitMessage);
+    const publishCommand = [
+      `git add ${addTargets}`,
+      `if git diff --cached --quiet; then echo "No staged changes to publish."; else git commit -m ${commit}; fi`,
+      "git push",
+    ].join(" && ");
+
+    this.updateStatusBar(`Blog sync: pushing ${target.label}...`);
+    const output = await this.runShellCommand(publishCommand, repoFolder);
+    this.updateStatusBar("Blog sync: published");
+    new Notice(
+      output.includes("No staged changes")
+        ? `No ${target.label} changes to publish.`
+        : `${target.label} changes pushed.`,
+    );
+  }
+
+  async ensureDevServer(target) {
+    const baseUrl = normalizeBaseUrl(target.devServerUrl);
+    if (await urlResponds(baseUrl)) {
+      return;
+    }
+
+    const existing = this.devServers.get(target.id);
+    if (existing?.process && !existing.process.killed) {
+      try {
+        await waitForUrl(baseUrl, 3000, () => existing.output);
+        return;
+      } catch (_) {
+        existing.process.kill();
+        this.devServers.delete(target.id);
+      }
+    }
+
+    const cwd = path.resolve(target.appFolder || target.repoFolder);
+    const shell =
+      this.settings.devServerShell || DEFAULT_SETTINGS.devServerShell;
+    const command = target.devServerCommand;
+    await this.logDebug(
+      `Starting dev server for ${target.id} with shell=${shell}, cwd=${cwd}, command=${command}, PATH=${this.getCommandEnv().PATH}`,
+    );
+    const state = { process: null, output: "" };
+    let exited = false;
+    let exitCode = null;
+
+    state.process = spawn(shell, ["-lc", command], {
+      cwd,
+      env: this.getCommandEnv(),
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    this.devServers.set(target.id, state);
+
+    state.process.stdout.on("data", (chunk) => {
+      state.output = trimOutput(`${state.output}${chunk.toString()}`);
+    });
+
+    state.process.stderr.on("data", (chunk) => {
+      state.output = trimOutput(`${state.output}${chunk.toString()}`);
+    });
+
+    state.process.on("exit", (code) => {
+      exited = true;
+      exitCode = code;
+      if (code !== 0 && code !== null) {
+        console.warn("Blog dev server exited", target.id, code, state.output);
+        this.logDebug(
+          `Dev server exited for ${target.id} with code ${code}: ${state.output}`,
+        );
+      }
+      this.devServers.delete(target.id);
+    });
+
+    await waitForUrl(
+      baseUrl,
+      Number(this.settings.devServerReadyTimeoutMs) ||
+        DEFAULT_SETTINGS.devServerReadyTimeoutMs,
+      () => {
+        if (exited) {
+          return `Dev server exited with code ${exitCode}.\n${state.output}`;
+        }
+
+        return state.output;
+      },
+      () => exited,
+    );
+  }
+
+  async runShellCommand(command, cwd) {
+    const shell =
+      this.settings.devServerShell || DEFAULT_SETTINGS.devServerShell;
+
+    return await new Promise((resolve, reject) => {
+      let output = "";
+      const child = spawn(shell, ["-lc", command], {
+        cwd,
+        env: this.getCommandEnv(),
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+
+      child.stdout.on("data", (chunk) => {
+        output = trimOutput(`${output}${chunk.toString()}`);
+      });
+
+      child.stderr.on("data", (chunk) => {
+        output = trimOutput(`${output}${chunk.toString()}`);
+      });
+
+      child.on("error", reject);
+      child.on("exit", (code) => {
+        if (code === 0) {
+          resolve(output);
+          return;
+        }
+
+        reject(
+          new Error(`${command} failed with exit code ${code}\n${output}`),
+        );
+      });
+    });
+  }
+
+  getDebugLogPath() {
+    const configuredPath =
+      this.settings.debugLogPath || DEFAULT_SETTINGS.debugLogPath;
+    if (path.isAbsolute(configuredPath)) {
+      return configuredPath;
+    }
+
+    return path.join(this.getVaultRoot(), configuredPath);
+  }
+
+  getCommandEnv() {
+    const pathPrepend =
+      this.settings.commandPathPrepend || DEFAULT_SETTINGS.commandPathPrepend;
+    const existingPath = process.env.PATH || "/usr/bin:/bin:/usr/sbin:/sbin";
+    const commandPath = pathPrepend
+      ? `${pathPrepend}:${existingPath}`
+      : existingPath;
+    return {
+      ...process.env,
+      PATH: commandPath,
+    };
+  }
+
+  async logDebug(message) {
+    try {
+      const logPath = this.getDebugLogPath();
+      await fs.mkdir(path.dirname(logPath), { recursive: true });
+      await fs.appendFile(
+        logPath,
+        `[${new Date().toISOString()}] ${message}\n`,
+      );
+    } catch (error) {
+      console.warn("Blog sync could not write debug log", error);
+    }
+  }
+
+  getActiveFilePath() {
+    const file = this.app.workspace.getActiveFile();
+    if (!file) {
+      throw new Error("Open a blog note first.");
+    }
+
+    return file.path;
+  }
+
+  getPreviewUrl(filePath, target) {
+    const slug = this.getSlugForVaultPath(filePath, target);
+    const baseUrl = normalizeBaseUrl(target.devServerUrl);
+    if (!slug) {
+      return `${baseUrl}/`;
+    }
+
+    const prefix = normalizeUrlPath(target.previewPathPrefix || "");
+    return `${baseUrl}${prefix}/${slug}/`;
+  }
+
+  getContentRepoPath(filePath, target) {
+    const folder = normalizeRelativePath(target.vaultFolder);
+    const normalized = normalizeRelativePath(filePath);
+    if (normalized !== folder && !normalized.startsWith(`${folder}/`)) {
+      throw new Error(
+        `Open a Markdown note under ${target.vaultFolder} first.`,
+      );
+    }
+
+    const relativePath = normalized.slice(folder.length + 1);
+    const logicalPath = vaultToLogicalPath(relativePath);
+    const contentFolder = path.resolve(target.contentFolder);
+    const repoFolder = path.resolve(target.repoFolder);
+    return toPosix(
+      path.relative(
+        repoFolder,
+        path.join(contentFolder, fromPosix(logicalPath)),
+      ),
+    );
+  }
+
+  getSlugForVaultPath(filePath, target) {
+    const folder = normalizeRelativePath(target.vaultFolder);
+    const normalized = normalizeRelativePath(filePath);
+    if (normalized !== folder && !normalized.startsWith(`${folder}/`)) {
+      return null;
+    }
+
+    const relativePath = normalized.slice(folder.length + 1);
+    const ext = path.extname(relativePath).toLowerCase();
+    if (!MARKDOWN_EXTENSIONS.has(ext)) {
+      return null;
+    }
+
+    const withoutExt = toPosix(relativePath).slice(0, -ext.length);
+    if (withoutExt.endsWith("/index")) {
+      return withoutExt.slice(0, -"/index".length);
+    }
+
+    return withoutExt;
+  }
+
+  async sync(direction, target = null) {
+    if (this.isSyncing) {
+      return { copied: 0, deleted: 0, skipped: 0 };
+    }
+
+    this.isSyncing = true;
+    try {
+      const targets = target ? [target] : this.getTargets();
+      const total = { copied: 0, deleted: 0, skipped: 0 };
+      for (const currentTarget of targets) {
+        const result = await this.syncTarget(direction, currentTarget);
+        total.copied += result.copied;
+        total.deleted += result.deleted;
+        total.skipped += result.skipped;
+      }
+      return total;
+    } finally {
+      this.isSyncing = false;
+    }
+  }
+
+  async syncTarget(direction, target) {
+    const vaultRoot = this.getVaultRoot();
+    const vaultFolder = path.resolve(vaultRoot, target.vaultFolder);
+    const contentFolder = path.resolve(target.contentFolder);
+    const extensions = getIncludedExtensions(this.settings.includeExtensions);
+
+    await fs.mkdir(vaultFolder, { recursive: true });
+    await fs.mkdir(contentFolder, { recursive: true });
+
+    const vaultEntries = await collectFiles(
+      vaultFolder,
+      extensions,
+      "vault",
+      this.settings.ignoreDraftMarkdown,
+    );
+    const contentEntries = await collectFiles(
+      contentFolder,
+      extensions,
+      "content",
+      this.settings.ignoreDraftMarkdown,
+    );
+
+    if (direction === "repo-to-vault") {
+      return await syncOneWay(
+        contentEntries,
+        vaultEntries,
+        contentFolder,
+        vaultFolder,
+        this.settings.deleteOrphans,
+      );
+    }
+
+    if (direction === "two-way") {
+      return await syncTwoWay(
+        vaultEntries,
+        contentEntries,
+        vaultFolder,
+        contentFolder,
+      );
+    }
+
+    return await syncOneWay(
+      vaultEntries,
+      contentEntries,
+      vaultFolder,
+      contentFolder,
+      this.settings.deleteOrphans,
+    );
+  }
+
+  getVaultRoot() {
+    const adapter = this.app.vault.adapter;
+    if (!adapter || typeof adapter.getBasePath !== "function") {
+      throw new Error(
+        "This plugin needs Obsidian's desktop filesystem adapter.",
+      );
+    }
+
+    return adapter.getBasePath();
+  }
+};
+
+class BlogFamilySyncSettingTab extends PluginSettingTab {
+  constructor(app, plugin) {
+    super(app, plugin);
+    this.plugin = plugin;
+  }
+
+  display() {
+    const { containerEl } = this;
+    containerEl.empty();
+
+    containerEl.createEl("h2", { text: "Blog Family Sync" });
+
+    const targetList = containerEl.createEl("div");
+    targetList.createEl("p", {
+      text: "Configured blog folders:",
+    });
+    const ul = targetList.createEl("ul");
+    for (const target of this.plugin.getTargets()) {
+      ul.createEl("li", {
+        text: `${target.label}: ${target.vaultFolder} -> ${target.contentFolder}`,
+      });
+    }
+
+    new Setting(containerEl)
+      .setName("Default sync direction")
+      .setDesc("Use Vault -> repo if Obsidian is the source of truth.")
+      .addDropdown((dropdown) =>
+        dropdown
+          .addOption("vault-to-repo", "Vault -> repo")
+          .addOption("repo-to-vault", "Repo -> vault")
+          .addOption("two-way", "Two-way, newest file wins")
+          .setValue(this.plugin.settings.syncDirection)
+          .onChange(async (value) => {
+            this.plugin.settings.syncDirection = value;
+            await this.plugin.saveSettings();
+          }),
+      );
+
+    new Setting(containerEl)
+      .setName("Auto-sync on vault changes")
+      .setDesc(
+        "When enabled, changes under any configured blog folder trigger sync for that blog.",
+      )
+      .addToggle((toggle) =>
+        toggle
+          .setValue(this.plugin.settings.autoSyncOnChange)
+          .onChange(async (value) => {
+            this.plugin.settings.autoSyncOnChange = value;
+            await this.plugin.saveSettings();
+            await this.plugin.restartWatchers();
+          }),
+      );
+
+    new Setting(containerEl)
+      .setName("Watch filesystem changes")
+      .setDesc("Uses the desktop filesystem watcher to catch changes quickly.")
+      .addToggle((toggle) =>
+        toggle
+          .setValue(this.plugin.settings.watchFilesystemChanges)
+          .onChange(async (value) => {
+            this.plugin.settings.watchFilesystemChanges = value;
+            await this.plugin.saveSettings();
+            await this.plugin.restartWatchers();
+          }),
+      );
+
+    new Setting(containerEl)
+      .setName("Poll for external file changes")
+      .setDesc("Catches edits made outside Obsidian.")
+      .addToggle((toggle) =>
+        toggle
+          .setValue(this.plugin.settings.pollForExternalChanges)
+          .onChange(async (value) => {
+            this.plugin.settings.pollForExternalChanges = value;
+            await this.plugin.saveSettings();
+            await this.plugin.restartWatchers();
+          }),
+      );
+
+    new Setting(containerEl)
+      .setName("Polling interval")
+      .setDesc("Milliseconds between scans. Minimum is 1000.")
+      .addText((text) =>
+        text
+          .setPlaceholder(String(DEFAULT_SETTINGS.pollIntervalMs))
+          .setValue(String(this.plugin.settings.pollIntervalMs))
+          .onChange(async (value) => {
+            this.plugin.settings.pollIntervalMs =
+              Number(value) || DEFAULT_SETTINGS.pollIntervalMs;
+            await this.plugin.saveSettings();
+            await this.plugin.restartWatchers();
+          }),
+      );
+
+    new Setting(containerEl)
+      .setName("Sync once when plugin loads")
+      .setDesc("Useful when Obsidian starts after files changed on disk.")
+      .addToggle((toggle) =>
+        toggle
+          .setValue(this.plugin.settings.syncOnStartup)
+          .onChange(async (value) => {
+            this.plugin.settings.syncOnStartup = value;
+            await this.plugin.saveSettings();
+          }),
+      );
+
+    new Setting(containerEl)
+      .setName("Show status bar item")
+      .setDesc("Shows the latest sync status at the bottom of Obsidian.")
+      .addToggle((toggle) =>
+        toggle
+          .setValue(this.plugin.settings.showStatusBar)
+          .onChange(async (value) => {
+            this.plugin.settings.showStatusBar = value;
+            await this.plugin.saveSettings();
+            this.plugin.updateStatusBar("Blog sync: idle");
+          }),
+      );
+
+    new Setting(containerEl)
+      .setName("Ignore draft Markdown")
+      .setDesc(
+        "Skips empty Markdown files and Obsidian's default Untitled drafts.",
+      )
+      .addToggle((toggle) =>
+        toggle
+          .setValue(this.plugin.settings.ignoreDraftMarkdown)
+          .onChange(async (value) => {
+            this.plugin.settings.ignoreDraftMarkdown = value;
+            await this.plugin.saveSettings();
+            await this.plugin.restartWatchers();
+          }),
+      );
+
+    new Setting(containerEl)
+      .setName("Delete orphaned target files")
+      .setDesc(
+        "Only applies to one-way sync. Leave this off unless you want deletions mirrored.",
+      )
+      .addToggle((toggle) =>
+        toggle
+          .setValue(this.plugin.settings.deleteOrphans)
+          .onChange(async (value) => {
+            this.plugin.settings.deleteOrphans = value;
+            await this.plugin.saveSettings();
+          }),
+      );
+
+    new Setting(containerEl)
+      .setName("Included extensions")
+      .setDesc("Comma-separated extensions synced as content/assets.")
+      .addText((text) =>
+        text
+          .setPlaceholder(DEFAULT_SETTINGS.includeExtensions)
+          .setValue(this.plugin.settings.includeExtensions)
+          .onChange(async (value) => {
+            this.plugin.settings.includeExtensions =
+              value || DEFAULT_SETTINGS.includeExtensions;
+            await this.plugin.saveSettings();
+          }),
+      );
+
+    containerEl.createEl("h3", { text: "Preview and Publish" });
+
+    new Setting(containerEl)
+      .setName("Dev server ready timeout")
+      .setDesc(
+        "Milliseconds to wait for local Astro before reporting captured startup output.",
+      )
+      .addText((text) =>
+        text
+          .setPlaceholder(String(DEFAULT_SETTINGS.devServerReadyTimeoutMs))
+          .setValue(String(this.plugin.settings.devServerReadyTimeoutMs))
+          .onChange(async (value) => {
+            this.plugin.settings.devServerReadyTimeoutMs =
+              Number(value) || DEFAULT_SETTINGS.devServerReadyTimeoutMs;
+            await this.plugin.saveSettings();
+          }),
+      );
+
+    new Setting(containerEl)
+      .setName("Open preview even if server start fails")
+      .setDesc("Useful only if you usually start the Astro server yourself.")
+      .addToggle((toggle) =>
+        toggle
+          .setValue(this.plugin.settings.openPreviewEvenIfServerStartFails)
+          .onChange(async (value) => {
+            this.plugin.settings.openPreviewEvenIfServerStartFails = value;
+            await this.plugin.saveSettings();
+          }),
+      );
+
+    new Setting(containerEl)
+      .setName("Debug log path")
+      .setDesc("Relative to the vault unless absolute.")
+      .addText((text) =>
+        text
+          .setPlaceholder(DEFAULT_SETTINGS.debugLogPath)
+          .setValue(this.plugin.settings.debugLogPath)
+          .onChange(async (value) => {
+            this.plugin.settings.debugLogPath =
+              value || DEFAULT_SETTINGS.debugLogPath;
+            await this.plugin.saveSettings();
+          }),
+      );
+
+    new Setting(containerEl)
+      .setName("Shell")
+      .setDesc("Shell used to run dev and publish commands.")
+      .addText((text) =>
+        text
+          .setPlaceholder(DEFAULT_SETTINGS.devServerShell)
+          .setValue(this.plugin.settings.devServerShell)
+          .onChange(async (value) => {
+            this.plugin.settings.devServerShell =
+              value || DEFAULT_SETTINGS.devServerShell;
+            await this.plugin.saveSettings();
+          }),
+      );
+
+    new Setting(containerEl)
+      .setName("Command PATH prefix")
+      .setDesc("Prepended to PATH when running npm/git commands from Obsidian.")
+      .addText((text) =>
+        text
+          .setPlaceholder(DEFAULT_SETTINGS.commandPathPrepend)
+          .setValue(this.plugin.settings.commandPathPrepend)
+          .onChange(async (value) => {
+            this.plugin.settings.commandPathPrepend =
+              value || DEFAULT_SETTINGS.commandPathPrepend;
+            await this.plugin.saveSettings();
+          }),
+      );
+
+    new Setting(containerEl)
+      .setName("Sync all now")
+      .setDesc("Run the configured sync direction for every configured blog.")
+      .addButton((button) =>
+        button
+          .setButtonText("Sync all")
+          .setCta()
+          .onClick(() => {
+            this.plugin.syncWithNotice(this.plugin.settings.syncDirection);
+          }),
+      );
+
+    new Setting(containerEl)
+      .setName("Preview current note")
+      .setDesc(
+        "Sync, start the matching local Astro dev server if needed, and open the current post.",
+      )
+      .addButton((button) =>
+        button.setButtonText("Sync and preview").onClick(() => {
+          this.plugin.syncAndPreviewCurrentNote();
+        }),
+      );
+
+    new Setting(containerEl)
+      .setName("Publish current note")
+      .setDesc("Sync, build, commit the current post, and push.")
+      .addButton((button) =>
+        button.setButtonText("Publish current").onClick(() => {
+          this.plugin.publishCurrentNote();
+        }),
+      );
+
+    new Setting(containerEl)
+      .setName("Publish current blog")
+      .setDesc(
+        "Sync, build, commit all content changes for the current blog, and push.",
+      )
+      .addButton((button) =>
+        button.setButtonText("Publish blog").onClick(() => {
+          this.plugin.publishCurrentBlog();
+        }),
+      );
+  }
+}
+
+function blogTarget(id, label, vaultFolder, port) {
+  return {
+    id,
+    label,
+    vaultFolder: `blogs/${vaultFolder}`,
+    repoFolder: ALLBLOGS_REPO,
+    appFolder: `${ALLBLOGS_REPO}/sites/${id}`,
+    contentFolder: `${ALLBLOGS_REPO}/sites/${id}/src/content/${id}`,
+    previewPathPrefix: "",
+    devServerUrl: `http://127.0.0.1:${port}`,
+    devServerCommand: `${NPM} run dev -- --host 127.0.0.1 --port ${port} --strictPort`,
+    publishBuildCommand: `${NPM} run build --prefix sites/${id}`,
+    publishCommitMessage: `Publish ${label.toLowerCase()} blog updates`,
+    stageAllPaths: [`sites/${id}/src/content/${id}`],
+    extraCurrentStagePaths: [],
+  };
+}
+
+function normalizeTarget(target) {
+  const defaults =
+    DEFAULT_TARGETS.find((candidate) => candidate.id === target.id) || {};
+  return Object.assign({}, defaults, target);
+}
+
+async function collectFiles(root, extensions, side, ignoreDraftMarkdown) {
+  const files = await walk(root);
+  const entries = new Map();
+
+  for (const absolutePath of files) {
+    const relativePath = toPosix(path.relative(root, absolutePath));
+    if (isHiddenPath(relativePath)) {
+      continue;
+    }
+
+    const ext = path.extname(relativePath).toLowerCase();
+    if (!extensions.has(ext)) {
+      continue;
+    }
+
+    const stat = await fs.stat(absolutePath);
+    if (
+      ignoreDraftMarkdown &&
+      MARKDOWN_EXTENSIONS.has(ext) &&
+      shouldSkipDraftMarkdown(relativePath, stat)
+    ) {
+      continue;
+    }
+
+    const logicalPath =
+      side === "vault"
+        ? vaultToLogicalPath(relativePath)
+        : toPosix(relativePath);
+    entries.set(logicalPath, {
+      absolutePath,
+      relativePath,
+      logicalPath,
+      mtimeMs: stat.mtimeMs,
+      size: stat.size,
+      ext,
+    });
+  }
+
+  return entries;
+}
+
+async function walk(root) {
+  let dirents = [];
+  try {
+    dirents = await fs.readdir(root, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+
+  const paths = [];
+  for (const dirent of dirents) {
+    const absolutePath = path.join(root, dirent.name);
+    if (dirent.isDirectory()) {
+      paths.push(...(await walk(absolutePath)));
+    } else if (dirent.isFile()) {
+      paths.push(absolutePath);
+    }
+  }
+
+  return paths;
+}
+
+async function syncOneWay(
+  sourceEntries,
+  targetEntries,
+  sourceRoot,
+  targetRoot,
+  deleteOrphans,
+) {
+  const result = { copied: 0, deleted: 0, skipped: 0 };
+
+  for (const [logicalPath, source] of sourceEntries) {
+    const targetRelativePath = targetPathForLogical(
+      logicalPath,
+      targetRoot,
+      targetEntries,
+    );
+    const targetAbsolutePath = path.join(
+      targetRoot,
+      fromPosix(targetRelativePath),
+    );
+    const target = targetEntries.get(logicalPath);
+
+    if (
+      target &&
+      (await sameFileContent(source.absolutePath, target.absolutePath))
+    ) {
+      result.skipped += 1;
+      continue;
+    }
+
+    await copyFile(source.absolutePath, targetAbsolutePath, source.mtimeMs);
+    result.copied += 1;
+  }
+
+  if (deleteOrphans) {
+    for (const [logicalPath, target] of targetEntries) {
+      if (!sourceEntries.has(logicalPath)) {
+        await fs.rm(target.absolutePath, { force: true });
+        await removeEmptyParents(path.dirname(target.absolutePath), targetRoot);
+        result.deleted += 1;
+      }
+    }
+  }
+
+  return result;
+}
+
+async function syncTwoWay(
+  vaultEntries,
+  contentEntries,
+  vaultRoot,
+  contentRoot,
+) {
+  const result = { copied: 0, deleted: 0, skipped: 0 };
+  const logicalPaths = new Set([
+    ...vaultEntries.keys(),
+    ...contentEntries.keys(),
+  ]);
+
+  for (const logicalPath of logicalPaths) {
+    const vault = vaultEntries.get(logicalPath);
+    const content = contentEntries.get(logicalPath);
+
+    if (vault && content) {
+      if (await sameFileContent(vault.absolutePath, content.absolutePath)) {
+        result.skipped += 1;
+        continue;
+      }
+
+      if (vault.mtimeMs >= content.mtimeMs) {
+        await copyFile(
+          vault.absolutePath,
+          path.join(contentRoot, fromPosix(logicalPath)),
+          vault.mtimeMs,
+        );
+      } else {
+        const targetRelativePath = targetPathForLogical(
+          logicalPath,
+          vaultRoot,
+          vaultEntries,
+        );
+        await copyFile(
+          content.absolutePath,
+          path.join(vaultRoot, fromPosix(targetRelativePath)),
+          content.mtimeMs,
+        );
+      }
+      result.copied += 1;
+      continue;
+    }
+
+    if (vault) {
+      await copyFile(
+        vault.absolutePath,
+        path.join(contentRoot, fromPosix(logicalPath)),
+        vault.mtimeMs,
+      );
+      result.copied += 1;
+      continue;
+    }
+
+    if (content) {
+      const targetRelativePath = targetPathForLogical(
+        logicalPath,
+        vaultRoot,
+        vaultEntries,
+      );
+      await copyFile(
+        content.absolutePath,
+        path.join(vaultRoot, fromPosix(targetRelativePath)),
+        content.mtimeMs,
+      );
+      result.copied += 1;
+    }
+  }
+
+  return result;
+}
+
+function vaultToLogicalPath(relativePath) {
+  const normalized = toPosix(relativePath);
+  const ext = path.extname(normalized).toLowerCase();
+
+  if (!MARKDOWN_EXTENSIONS.has(ext)) {
+    return normalized;
+  }
+
+  if (!normalized.includes("/")) {
+    const slug = normalized.slice(0, -ext.length);
+    return `${slug}/index${ext}`;
+  }
+
+  return normalized;
+}
+
+function targetPathForLogical(logicalPath, targetRoot, targetEntries) {
+  const ext = path.extname(logicalPath).toLowerCase();
+  if (!MARKDOWN_EXTENSIONS.has(ext)) {
+    return logicalPath;
+  }
+
+  const match = logicalPath.match(/^([^/]+)\/index(\.mdx?)$/);
+  if (!match) {
+    return logicalPath;
+  }
+
+  const flatPath = `${match[1]}${match[2]}`;
+  const existingFlat = path.join(targetRoot, fromPosix(flatPath));
+  if (
+    targetEntries.has(logicalPath) &&
+    targetEntries.get(logicalPath).relativePath === flatPath
+  ) {
+    return flatPath;
+  }
+
+  try {
+    const stat = nodeFs.statSync(existingFlat);
+    if (stat.isFile()) {
+      return flatPath;
+    }
+  } catch (_) {
+    // Fall through to folder/index form.
+  }
+
+  return logicalPath;
+}
+
+async function copyFile(source, target, mtimeMs) {
+  await fs.mkdir(path.dirname(target), { recursive: true });
+  await fs.copyFile(source, target);
+  const mtime = new Date(mtimeMs);
+  await fs.utimes(target, mtime, mtime);
+}
+
+async function sameFileContent(left, right) {
+  try {
+    const [leftBuffer, rightBuffer] = await Promise.all([
+      fs.readFile(left),
+      fs.readFile(right),
+    ]);
+    return leftBuffer.equals(rightBuffer);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+
+async function removeEmptyParents(start, stop) {
+  let current = path.resolve(start);
+  const stopAt = path.resolve(stop);
+
+  while (current.startsWith(stopAt) && current !== stopAt) {
+    try {
+      await fs.rmdir(current);
+    } catch (_) {
+      return;
+    }
+    current = path.dirname(current);
+  }
+}
+
+function getIncludedExtensions(value) {
+  const extensions = new Set();
+  for (const part of String(value || "").split(",")) {
+    const cleaned = part.trim().toLowerCase();
+    if (!cleaned) {
+      continue;
+    }
+    extensions.add(cleaned.startsWith(".") ? cleaned : `.${cleaned}`);
+  }
+  return extensions;
+}
+
+async function openExternalUrl(url) {
+  try {
+    const electron = require("electron");
+    if (electron?.shell?.openExternal) {
+      await electron.shell.openExternal(url);
+      return;
+    }
+  } catch (_) {
+    // Fall back to macOS open below.
+  }
+
+  const child = spawn("/usr/bin/open", [url], {
+    detached: true,
+    stdio: "ignore",
+  });
+  child.unref();
+}
+
+async function waitForUrl(url, timeoutMs, getOutput, shouldAbort) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (await urlResponds(url)) {
+      return;
+    }
+
+    if (typeof shouldAbort === "function" && shouldAbort()) {
+      const output = typeof getOutput === "function" ? getOutput() : "";
+      throw new Error(
+        `Dev server stopped before ${url} was ready.${output ? `\n${output}` : ""}`,
+      );
+    }
+
+    await delay(500);
+  }
+
+  const output = typeof getOutput === "function" ? getOutput() : "";
+  throw new Error(
+    `Timed out waiting for ${url}.${output ? `\n${output}` : ""}`,
+  );
+}
+
+function urlResponds(url) {
+  return new Promise((resolve) => {
+    let parsed;
+    try {
+      parsed = new URL(url);
+    } catch (_) {
+      resolve(false);
+      return;
+    }
+
+    const client = parsed.protocol === "https:" ? https : http;
+    const request = client.request(
+      {
+        hostname: parsed.hostname,
+        port: parsed.port || (parsed.protocol === "https:" ? 443 : 80),
+        path: `${parsed.pathname}${parsed.search}`,
+        method: "GET",
+        timeout: 1200,
+      },
+      (response) => {
+        response.resume();
+        resolve(response.statusCode >= 200 && response.statusCode < 500);
+      },
+    );
+
+    request.on("timeout", () => {
+      request.destroy();
+      resolve(false);
+    });
+    request.on("error", () => resolve(false));
+    request.end();
+  });
+}
+
+function delay(ms) {
+  return new Promise((resolve) => window.setTimeout(resolve, ms));
+}
+
+function normalizeBaseUrl(value) {
+  return String(value || "").replace(/\/+$/, "");
+}
+
+function normalizeUrlPath(value) {
+  const cleaned = String(value || "").replace(/^\/+|\/+$/g, "");
+  return cleaned ? `/${cleaned}` : "";
+}
+
+function normalizeDirection(value) {
+  if (value === "vault-to-micro") {
+    return "vault-to-repo";
+  }
+  if (value === "micro-to-vault") {
+    return "repo-to-vault";
+  }
+  if (value === "repo-to-vault" || value === "two-way") {
+    return value;
+  }
+  return "vault-to-repo";
+}
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, "'\\''")}'`;
+}
+
+function trimOutput(value) {
+  const maxLength = 20000;
+  if (value.length <= maxLength) {
+    return value;
+  }
+
+  return value.slice(value.length - maxLength);
+}
+
+function normalizeRelativePath(value) {
+  return String(value || "")
+    .replace(/\\/g, "/")
+    .replace(/^\/+/, "")
+    .replace(/\/+$/, "");
+}
+
+function isHiddenPath(relativePath) {
+  return relativePath.startsWith(".") || relativePath.includes("/.");
+}
+
+function shouldSkipDraftMarkdown(relativePath, stat) {
+  const normalized = toPosix(relativePath);
+  if (stat.size === 0) {
+    return true;
+  }
+
+  return /(^|\/)Untitled(\.mdx?|\/index\.mdx?)$/i.test(normalized);
+}
+
+function toPosix(value) {
+  return value.split(path.sep).join("/");
+}
+
+function fromPosix(value) {
+  return value.split("/").join(path.sep);
+}
diff --git a/obsidian-plugin/microblog-sync/manifest.json b/obsidian-plugin/microblog-sync/manifest.json
new file mode 100644
index 0000000..1abb168
--- /dev/null
+++ b/obsidian-plugin/microblog-sync/manifest.json
@@ -0,0 +1,9 @@
+{
+  "id": "microblog-sync",
+  "name": "Blog Family Sync",
+  "version": "0.4.0",
+  "minAppVersion": "1.5.0",
+  "description": "Sync the public Obsidian blog folders with the local Astro blog repos.",
+  "author": "Neeldhara Misra",
+  "isDesktopOnly": true
+}
diff --git a/scripts/import-quarto-blog.mjs b/scripts/import-quarto-blog.mjs
new file mode 100644
index 0000000..abc85e5
--- /dev/null
+++ b/scripts/import-quarto-blog.mjs
@@ -0,0 +1,634 @@
+#!/usr/bin/env node
+import fs from "node:fs/promises";
+import nodeFs from "node:fs";
+import path from "node:path";
+
+const DEFAULT_SOURCE = "/private/tmp/quartosite-shallow/blog";
+const DEFAULT_OUTPUT = "/private/tmp/quarto-blog-import";
+
+const sourceRoot = path.resolve(process.argv[2] || DEFAULT_SOURCE);
+const outputRoot = path.resolve(process.argv[3] || DEFAULT_OUTPUT);
+
+const blogs = [
+  { key: "research", vaultFolder: "01-research", title: "Research" },
+  { key: "vibes", vaultFolder: "02-vibes", title: "Vibes" },
+  { key: "puzzles", vaultFolder: "03-puzzles", title: "Puzzles" },
+  { key: "reflections", vaultFolder: "04-reflections", title: "Reflections" },
+  { key: "poetry", vaultFolder: "05-poetry", title: "Poetry" },
+  { key: "reviews", vaultFolder: "06-reviews", title: "Reviews" },
+  { key: "art", vaultFolder: "07-art", title: "Art" },
+];
+
+const blogByKey = new Map(blogs.map((blog) => [blog.key, blog]));
+
+const explicitDestinations = new Map([
+  ["13sheep/index.qmd", "vibes"],
+  ["15-puzzle/index.qmd", "puzzles"],
+  ["2023-exportober-workflows/index.qmd", "reviews"],
+  ["building-interactives/index.qmd", "vibes"],
+  ["building-websites-with-notion/index.qmd", "reviews"],
+  ["comms/index.qmd", "art"],
+  ["communication-complexity-equality/index.qmd", "art"],
+  ["course-plan/2024-fall/index.qmd", "vibes"],
+  ["course-plan/2024-spring/index.qmd", "vibes"],
+  ["course-plan/index.qmd", "vibes"],
+  ["cp/sam-i-am/index.qmd", "research"],
+  ["crypto-intro/index.qmd", "research"],
+  ["django-app/index.qmd", "reviews"],
+  ["dogs-bunny-puzzle/index.qmd", "puzzles"],
+  ["eight-self-sabotaging-behaviors/index.qmd", "reflections"],
+  ["envelope-budgeting-notion/index.qmd", "reviews"],
+  ["exportober/2021-tracker/index.qmd", "reflections"],
+  ["exportober/2021/index.qmd", "reflections"],
+  ["exportober/2022-tracker/index.qmd", "reflections"],
+  ["exportober/about/index.qmd", "reflections"],
+  ["homework-help/index.qmd", "research"],
+  ["iit-rankings/index.qmd", "reflections"],
+  ["indiamini-crosswords/index.qmd", "art"],
+  ["kidney-exchanges/index.qmd", "research"],
+  ["massren/index.qmd", "reviews"],
+  ["moving-blocks-ctis/index.qmd", "puzzles"],
+  ["new-mac/index.qmd", "reviews"],
+  ["note-taking-resources/index.qmd", "reviews"],
+  ["notion-powered-websites/index.qmd", "reviews"],
+  ["on-career-choices/index.qmd", "reflections"],
+  ["on-teaching/index.qmd", "reflections"],
+  ["pandoc-letters/index.qmd", "reviews"],
+  ["skj/index.qmd", "reflections"],
+  ["solo-chess/index.qmd", "puzzles"],
+  ["women-in-mathematics/index.qmd", "reviews"],
+]);
+
+const skippedDrafts = [];
+const importedPosts = [];
+
+await fs.rm(outputRoot, { recursive: true, force: true });
+await fs.mkdir(outputRoot, { recursive: true });
+
+for (const blog of blogs) {
+  await fs.mkdir(path.join(outputRoot, "obsidian", "blogs", blog.vaultFolder), {
+    recursive: true,
+  });
+  await fs.mkdir(
+    path.join(
+      outputRoot,
+      "astro",
+      "sites",
+      blog.key,
+      "src",
+      "content",
+      blog.key,
+    ),
+    { recursive: true },
+  );
+}
+
+const sourceFiles = (await walk(sourceRoot))
+  .filter((file) => /\.(qmd|md|markdown)$/i.test(file))
+  .sort();
+
+for (const sourceFile of sourceFiles) {
+  const relativePath = toPosix(path.relative(sourceRoot, sourceFile));
+  const sourceText = await fs.readFile(sourceFile, "utf8");
+  const { frontmatter, body } = parseFrontmatter(sourceText);
+
+  if (isDraft(frontmatter)) {
+    skippedDrafts.push(relativePath);
+    continue;
+  }
+
+  const blogKey = classifyPost(relativePath, frontmatter);
+  const blog = blogByKey.get(blogKey);
+  if (!blog) {
+    throw new Error(`Unknown blog key "${blogKey}" for ${relativePath}`);
+  }
+
+  const markdownRelativePath = relativePath.replace(
+    /\.(qmd|markdown)$/i,
+    ".md",
+  );
+  const convertedBody = convertQuartoMarkdown(body).trim();
+  const title = frontmatter.title || titleFromPath(relativePath);
+  const pubDate = normalizeDate(frontmatter.date);
+  const description =
+    frontmatter.description || summarize(convertedBody, title);
+  const categories = parseList(frontmatter.categories);
+  const markdown = [
+    "---",
+    `title: ${yamlString(title)}`,
+    `description: ${yamlString(description)}`,
+    `pubDate: ${yamlString(pubDate)}`,
+    'authorName: "Neeldhara"',
+    categories.length
+      ? `sourceCategories: [${categories.map(yamlString).join(", ")}]`
+      : "",
+    `sourcePath: ${yamlString(relativePath)}`,
+    "---",
+    "",
+    convertedBody,
+    "",
+  ]
+    .filter((line, index, lines) => line || lines[index - 1] !== "")
+    .join("\n");
+
+  const obsidianTarget = path.join(
+    outputRoot,
+    "obsidian",
+    "blogs",
+    blog.vaultFolder,
+    fromPosix(markdownRelativePath),
+  );
+  const astroTarget = path.join(
+    outputRoot,
+    "astro",
+    "sites",
+    blog.key,
+    "src",
+    "content",
+    blog.key,
+    fromPosix(markdownRelativePath),
+  );
+
+  await writeFileEnsured(obsidianTarget, markdown);
+  await writeFileEnsured(astroTarget, markdown);
+  await copyPostAssets(path.dirname(sourceFile), path.dirname(obsidianTarget));
+  await copyPostAssets(path.dirname(sourceFile), path.dirname(astroTarget));
+
+  importedPosts.push({
+    source: relativePath,
+    destination: `${blog.vaultFolder}/${markdownRelativePath}`,
+    blog: blog.key,
+    title,
+    date: pubDate,
+    categories,
+  });
+}
+
+await writeImportReport();
+await writeVaultReadme();
+await writeAstroManifest();
+
+console.log(`Imported ${importedPosts.length} posts into ${outputRoot}`);
+console.log(`Skipped ${skippedDrafts.length} draft posts.`);
+
+async function writeImportReport() {
+  const rows = [
+    "# Quarto Blog Import Report",
+    "",
+    `Source: ${sourceRoot}`,
+    `Generated: ${new Date().toISOString()}`,
+    "",
+    "## Imported Posts",
+    "",
+    "| Blog | Date | Title | Source | Destination |",
+    "| --- | --- | --- | --- | --- |",
+  ];
+
+  for (const post of importedPosts.sort(
+    (left, right) =>
+      left.blog.localeCompare(right.blog) ||
+      right.date.localeCompare(left.date),
+  )) {
+    rows.push(
+      `| ${post.blog} | ${post.date} | ${escapeTable(post.title)} | \`${post.source}\` | \`${post.destination}\` |`,
+    );
+  }
+
+  rows.push("", "## Skipped Drafts", "");
+  if (skippedDrafts.length) {
+    for (const draft of skippedDrafts) {
+      rows.push(`- \`${draft}\``);
+    }
+  } else {
+    rows.push("- None");
+  }
+
+  await writeFileEnsured(
+    path.join(outputRoot, "IMPORT_REPORT.md"),
+    `${rows.join("\n")}\n`,
+  );
+}
+
+async function writeVaultReadme() {
+  const readme = `# Blog Content Bridge
+
+This folder is the Obsidian source of truth for the public blog family.
+
+## Folder Map
+
+| Vault folder | Astro site | Public domain |
+| --- | --- | --- |
+| \`blogs/01-research\` | \`allblogs/sites/research/src/content/research\` | \`https://research.neeldhara.blog\` |
+| \`blogs/02-vibes\` | \`allblogs/sites/vibes/src/content/vibes\` | \`https://vibes.neeldhara.blog\` |
+| \`blogs/03-puzzles\` | \`allblogs/sites/puzzles/src/content/puzzles\` | \`https://puzzles.neeldhara.blog\` |
+| \`blogs/04-reflections\` | \`allblogs/sites/reflections/src/content/reflections\` | \`https://reflections.neeldhara.blog\` |
+| \`blogs/05-poetry\` | \`allblogs/sites/poetry/src/content/poetry\` | \`https://poetry.neeldhara.blog\` |
+| \`blogs/06-reviews\` | \`allblogs/sites/reviews/src/content/reviews\` | \`https://reviews.neeldhara.blog\` |
+| \`blogs/07-art\` | \`allblogs/sites/art/src/content/art\` | \`https://art.neeldhara.blog\` |
+| \`blogs/micro\` | \`micro/src/content/blog\` | \`https://micro.neeldhara.blog\` |
+
+The installed Obsidian plugin is still stored at:
+
+\`\`\`text
+.obsidian/plugins/microblog-sync
+\`\`\`
+
+The plugin name in Obsidian is **Blog Family Sync**. It watches all folders above, syncs edited files into the matching Astro repo, can start a local preview server for the current note, and can publish by running build, commit, and push.
+
+## Post Layout
+
+Use one folder per post:
+
+\`\`\`text
+blogs/01-research/example-post/index.md
+blogs/01-research/example-post/diagram.png
+\`\`\`
+
+The folder path becomes the public URL:
+
+\`\`\`text
+blogs/01-research/example-post/index.md
+https://research.neeldhara.blog/example-post/
+\`\`\`
+
+Nested folders are allowed. For example:
+
+\`\`\`text
+blogs/04-reflections/exportober/2021/index.md
+https://reflections.neeldhara.blog/exportober/2021/
+\`\`\`
+
+## Frontmatter
+
+Every public Markdown post should start with:
+
+\`\`\`yaml
+---
+title: "Post title"
+description: "One or two sentence summary for cards and RSS."
+pubDate: "2024-05-10"
+authorName: "Neeldhara"
+---
+\`\`\`
+
+\`title\`, \`description\`, and \`pubDate\` are required by the Astro schemas.
+\`updatedDate\`, \`image\`, and \`authorImage\` are optional. Prefer colocated images in the body over remote stock images.
+
+## Markdown Conventions
+
+- Standard Markdown headings, lists, links, tables, code fences, footnotes, and raw HTML are preserved.
+- Use colocated relative assets: \`![Caption](image.png)\`.
+- Quarto image attributes such as \`{width=70%}\` are removed during import. Use normal Markdown now; layout should be handled by Astro CSS.
+- Quarto callouts are converted to simple blockquotes:
+
+\`\`\`markdown
+> **Note**
+>
+> Text of the callout.
+\`\`\`
+
+- For new notes, use the same blockquote convention for portable callouts:
+
+\`\`\`markdown
+> **Warning**
+>
+> This point needs attention.
+\`\`\`
+
+- Quarto margin notes such as \`[text]{.aside}\` are converted to:
+
+\`\`\`markdown
+> **Aside:** text
+\`\`\`
+
+## Sync Rules
+
+- Obsidian is the source of truth.
+- Auto-sync copies changed files from the matching \`blogs/...\` folder into the matching local Astro content folder.
+- The plugin includes Markdown plus common web assets: images, PDFs, JSON/YAML, JS, CSS, HTML, and text files.
+- One-way sync does not delete target files unless **Delete orphaned target files** is enabled.
+- The initial Quarto import used replace-style sync to clear placeholder Astro posts. Day-to-day editing should use the plugin.
+
+## Publish
+
+Use **Blog Family Sync: Publish current note** or **Blog Family Sync: Publish all changes for current blog** from Obsidian. Publish does three things:
+
+1. Sync vault content into the local repo.
+2. Run the configured Astro build command.
+3. Commit and push to Forgejo, where Dokploy picks up the change.
+
+`;
+
+  await writeFileEnsured(
+    path.join(outputRoot, "obsidian", "blogs", "README.md"),
+    readme,
+  );
+}
+
+async function writeAstroManifest() {
+  const manifest = {
+    generatedAt: new Date().toISOString(),
+    sourceRoot,
+    importedPosts,
+    skippedDrafts,
+  };
+  await writeFileEnsured(
+    path.join(outputRoot, "manifest.json"),
+    `${JSON.stringify(manifest, null, 2)}\n`,
+  );
+}
+
+function classifyPost(relativePath, frontmatter) {
+  if (explicitDestinations.has(relativePath)) {
+    return explicitDestinations.get(relativePath);
+  }
+
+  const categories = parseList(frontmatter.categories).map((category) =>
+    category.toLowerCase(),
+  );
+  const haystack =
+    `${relativePath} ${frontmatter.title || ""} ${categories.join(" ")}`.toLowerCase();
+
+  if (relativePath.startsWith("poems/") || categories.includes("poem")) {
+    return "poetry";
+  }
+  if (categories.some((category) => ["puzzles", "games"].includes(category))) {
+    return "puzzles";
+  }
+  if (
+    categories.some((category) =>
+      [
+        "books",
+        "apps",
+        "workflows",
+        "tutorial",
+        "websites",
+        "notion",
+        "pandoc",
+        "lists",
+      ].includes(category),
+    )
+  ) {
+    return "reviews";
+  }
+  if (categories.some((category) => ["sketchnotes"].includes(category))) {
+    return "art";
+  }
+  if (haystack.includes("chatgpt") || haystack.includes("interactive")) {
+    return "vibes";
+  }
+  if (
+    categories.some((category) =>
+      [
+        "lecturenotes",
+        "talk",
+        "exposition",
+        "parameterized-algorithms",
+      ].includes(category),
+    )
+  ) {
+    return "research";
+  }
+  return "reflections";
+}
+
+function parseFrontmatter(text) {
+  if (!text.startsWith("---")) {
+    return { frontmatter: {}, body: text };
+  }
+
+  const end = text.indexOf("\n---", 3);
+  if (end < 0) {
+    return { frontmatter: {}, body: text };
+  }
+
+  const rawFrontmatter = text.slice(4, end).trim();
+  const body = text.slice(end + 4);
+  const frontmatter = {};
+  for (const line of rawFrontmatter.split(/\r?\n/)) {
+    const match = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+    if (!match) {
+      continue;
+    }
+
+    const [, key, rawValue] = match;
+    frontmatter[key] = unquote(rawValue.trim());
+  }
+
+  return { frontmatter, body };
+}
+
+function convertQuartoMarkdown(body) {
+  const lines = body.replace(/\r\n/g, "\n").split("\n");
+  const converted = [];
+  const calloutStack = [];
+  let inCodeFence = false;
+
+  for (const rawLine of lines) {
+    const line = rawLine.replace(/\s+$/, "");
+
+    if (/^```/.test(line.trim())) {
+      inCodeFence = !inCodeFence;
+      converted.push(prefixCalloutLine(line, calloutStack.length));
+      continue;
+    }
+
+    if (!inCodeFence) {
+      const calloutOpen = line.match(
+        /^\s*:::\s*\{?\.?callout-([A-Za-z0-9_-]+)[^}]*\}?\s*$/,
+      );
+      if (calloutOpen) {
+        calloutStack.push(calloutOpen[1]);
+        converted.push(
+          prefixCalloutLine(
+            `**${titleCase(calloutOpen[1])}**`,
+            calloutStack.length,
+          ),
+        );
+        converted.push(prefixCalloutLine("", calloutStack.length));
+        continue;
+      }
+
+      if (/^\s*:::\s*$/.test(line) && calloutStack.length) {
+        calloutStack.pop();
+        converted.push("");
+        continue;
+      }
+
+      if (/^\s*:{3,4}\s*\{/.test(line) || /^\s*:{3,4}\s*$/.test(line)) {
+        continue;
+      }
+    }
+
+    let cleaned = line;
+    if (!inCodeFence) {
+      cleaned = cleaned
+        .replace(
+          /(<script\b[^>]*><\/script>|<script\b[^>]*>.*?<\/script>)/gi,
+          "",
+        )
+        .replace(/!\[([^\]]*)\]\(([^)]+)\)\{[^}]+\}/g, "![$1]($2)")
+        .replace(/^\s*\[([^\]]+)\]\{\.aside\}\s*$/, "> **Aside:** $1")
+        .replace(/\[([^\]]+)\]\{\.smallcaps\}/g, "$1")
+        .replace(/\[([^\]]+)\]\{[^}]+\}/g, "$1");
+    }
+
+    converted.push(prefixCalloutLine(cleaned, calloutStack.length));
+  }
+
+  return converted.join("\n").replace(/\n{4,}/g, "\n\n\n");
+}
+
+function prefixCalloutLine(line, depth) {
+  if (!depth) {
+    return line;
+  }
+
+  return `${"> ".repeat(depth)}${line}`;
+}
+
+async function copyPostAssets(sourceDir, targetDir) {
+  const files = await fs.readdir(sourceDir, { withFileTypes: true });
+  for (const entry of files) {
+    if (
+      entry.name.startsWith(".") ||
+      /\.(qmd|md|markdown)$/i.test(entry.name)
+    ) {
+      continue;
+    }
+
+    const source = path.join(sourceDir, entry.name);
+    const target = path.join(targetDir, entry.name);
+    if (entry.isDirectory()) {
+      await fs.mkdir(target, { recursive: true });
+      await copyPostAssets(source, target);
+      continue;
+    }
+
+    if (entry.isFile()) {
+      await fs.mkdir(path.dirname(target), { recursive: true });
+      await fs.copyFile(source, target);
+    }
+  }
+}
+
+async function walk(root) {
+  const entries = await fs.readdir(root, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    if (entry.name.startsWith(".")) {
+      continue;
+    }
+
+    const absolutePath = path.join(root, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...(await walk(absolutePath)));
+    } else if (entry.isFile()) {
+      files.push(absolutePath);
+    }
+  }
+
+  return files;
+}
+
+async function writeFileEnsured(target, content) {
+  await fs.mkdir(path.dirname(target), { recursive: true });
+  await fs.writeFile(target, content);
+}
+
+function parseList(value) {
+  if (!value) {
+    return [];
+  }
+
+  const trimmed = String(value).trim();
+  if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    return trimmed
+      .slice(1, -1)
+      .split(",")
+      .map((item) => unquote(item.trim()))
+      .filter(Boolean);
+  }
+
+  return [unquote(trimmed)];
+}
+
+function isDraft(frontmatter) {
+  return String(frontmatter.draft || "").toLowerCase() === "true";
+}
+
+function normalizeDate(value) {
+  if (!value) {
+    return "2000-01-01";
+  }
+
+  const cleaned = String(value).replace(/^["']|["']$/g, "");
+  const match = cleaned.match(/^(\d{4})-(\d{2})-(\d{2})/);
+  if (match) {
+    return `${match[1]}-${match[2]}-${match[3]}`;
+  }
+
+  const date = new Date(cleaned);
+  if (Number.isNaN(date.valueOf())) {
+    return "2000-01-01";
+  }
+
+  return date.toISOString().slice(0, 10);
+}
+
+function summarize(markdown, title) {
+  const withoutBlocks = markdown
+    .replace(/```[\s\S]*?```/g, " ")
+    .replace(/<[^>]+>/g, " ")
+    .replace(/!\[[^\]]*\]\([^)]+\)/g, " ")
+    .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1")
+    .replace(/[#>*_`~$]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+
+  const summary = withoutBlocks || title;
+  return summary.length > 180 ? `${summary.slice(0, 177).trim()}...` : summary;
+}
+
+function titleFromPath(relativePath) {
+  const folder = relativePath.replace(/\/index\.(qmd|md|markdown)$/i, "");
+  const leaf = folder.split("/").pop() || "Untitled";
+  return leaf
+    .split(/[-_]+/)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join(" ");
+}
+
+function titleCase(value) {
+  return String(value)
+    .split(/[-_]+/)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join(" ");
+}
+
+function yamlString(value) {
+  return JSON.stringify(String(value || ""));
+}
+
+function unquote(value) {
+  if (
+    (value.startsWith('"') && value.endsWith('"')) ||
+    (value.startsWith("'") && value.endsWith("'"))
+  ) {
+    return value.slice(1, -1);
+  }
+
+  return value;
+}
+
+function escapeTable(value) {
+  return String(value).replace(/\|/g, "\\|");
+}
+
+function toPosix(value) {
+  return value.split(path.sep).join("/");
+}
+
+function fromPosix(value) {
+  return value.split("/").join(path.sep);
+}
diff --git a/sites/art/src/components/sections/blog-posts.tsx b/sites/art/src/components/sections/blog-posts.tsx
index fef77e5..c77c76a 100644
--- a/sites/art/src/components/sections/blog-posts.tsx
+++ b/sites/art/src/components/sections/blog-posts.tsx
@@ -16,8 +16,47 @@ const BlogPosts = ({
   // Get the first post as the featured post
   const featuredPost = posts[0];
   const remainingPosts = posts.slice(1);
+  const slugFor = (post: any) => post.id.replace(/\/index$/, "");
   const hrefFor = (post: any) =>
-    collection ? `/${collection}/${post.id}/` : `/${post.id}/`;
+    collection ? `/${collection}/${slugFor(post)}/` : `/${slugFor(post)}/`;
+
+  const PostVisual = ({
+    post,
+    featured = false,
+  }: {
+    post: any;
+    featured?: boolean;
+  }) => {
+    if (post.data.image) {
+      return (
+        <img
+          src={post.data.image}
+          alt={post.data.title}
+          className="aspect-video w-full rounded-lg object-cover transition-transform group-hover:scale-[1.02]"
+        />
+      );
+    }
+
+    return (
+      <div className="bg-accent/70 text-accent-foreground flex aspect-video w-full items-center justify-center rounded-lg border px-6 text-center">
+        <span
+          className={
+            featured ? "font-fraunces text-2xl" : "font-fraunces text-lg"
+          }
+        >
+          {post.data.title}
+        </span>
+      </div>
+    );
+  };
+
+  if (!featuredPost) {
+    return (
+      <div className="text-muted-foreground container max-w-3xl py-16">
+        No posts yet.
+      </div>
+    );
+  }
 
   return (
     <div className="relative py-10 md:py-16 lg:py-20">
@@ -35,11 +74,7 @@ const BlogPosts = ({
             <div className="flex flex-col gap-6 lg:flex-row">
               <div className="lg:w-1/2">
                 <div className="p-2 lg:p-4">
-                  <img
-                    src={featuredPost.data.image}
-                    alt={featuredPost.data.title}
-                    className="aspect-video w-full rounded-lg object-cover transition-transform group-hover:scale-[1.02]"
-                  />
+                  <PostVisual post={featuredPost} featured />
                 </div>
               </div>
               <div className="flex flex-col justify-center p-4 pb-8 lg:w-1/2 lg:pr-8">
@@ -89,11 +124,7 @@ const BlogPosts = ({
                 href={hrefFor(post)}
               >
                 <div className="p-2">
-                  <img
-                    src={post.data.image}
-                    alt={post.data.title}
-                    className="aspect-video w-full rounded-lg object-cover transition-transform group-hover:scale-[1.01]"
-                  />
+                  <PostVisual post={post} />
                 </div>
                 <div className="px-4 pb-5 pt-2">
                   <h2 className="mb-2 text-xl font-semibold group-hover:underline">
diff --git a/sites/art/src/content/art/algorithmic-sketches.md b/sites/art/src/content/art/algorithmic-sketches.md
deleted file mode 100644
index ae20d3b..0000000
--- a/sites/art/src/content/art/algorithmic-sketches.md
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title: "Algorithmic Sketches: Visualizing Data Structures"
-description: "Hand-drawn illustrations of algorithms and data structures - making the abstract tangible."
-pubDate: "Jan 25 2024"
-image: "https://images.unsplash.com/photo-1581337204873-ef36aa186caa?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Algorithmic Sketches: Visualizing Data Structures
-
-Sometimes the best way to understand an algorithm is to draw it.
-
-## Today's Sketch: Red-Black Trees
-
-![Red-Black Tree Rotation](sketch-placeholder)
-
-The rotation operation finally clicked when I drew it step-by-step. Each node's journey through the rotation becomes a story.
-
-## The Process
-
-1. Start with pencil - mistakes are part of learning
-2. Trace the algorithm's execution
-3. Add color to highlight invariants
-4. Annotate with key insights
-
-## Why Drawing Helps
-
-- Forces you to slow down and really see the structure
-- Reveals patterns that code obscures
-- Creates memorable mental models
-- Makes teaching more engaging
-
-## This Week's Challenge
-
-Draw your own version of quicksort partitioning. Share it and let's learn from each other's visualizations.
-
-## The Art in Computer Science
-
-Algorithms are beautiful. Drawing them reminds us that computer science is as much art as it is science.
diff --git a/sites/art/src/content/art/comms/1.jpg b/sites/art/src/content/art/comms/1.jpg
new file mode 100644
index 0000000..7b1854d
Binary files /dev/null and b/sites/art/src/content/art/comms/1.jpg differ
diff --git a/sites/art/src/content/art/comms/chand.png b/sites/art/src/content/art/comms/chand.png
new file mode 100644
index 0000000..8183d74
Binary files /dev/null and b/sites/art/src/content/art/comms/chand.png differ
diff --git a/sites/art/src/content/art/comms/chand2.png b/sites/art/src/content/art/comms/chand2.png
new file mode 100644
index 0000000..2c0e535
Binary files /dev/null and b/sites/art/src/content/art/comms/chand2.png differ
diff --git a/sites/art/src/content/art/comms/index.md b/sites/art/src/content/art/comms/index.md
new file mode 100644
index 0000000..e716a91
--- /dev/null
+++ b/sites/art/src/content/art/comms/index.md
@@ -0,0 +1,125 @@
+---
+title: "External Communications"
+description: "I finish seven years at IIT Gandhinagar today. This year, I also concluded my stint with the Department of External Communications, which feels about as long. Indeed, little did..."
+pubDate: "2022-09-23"
+authorName: "Neeldhara"
+sourceCategories: ["iitgn"]
+sourcePath: "comms/index.qmd"
+---
+
+I finish seven years at IIT Gandhinagar today.
+
+This year, I also concluded my stint with the Department of External Communications, which feels about as long. Indeed, little did I know that a casual remark that I had made during my interview^[This was during the summer of 2015, with [Prof. Sudhir Jain](https://sudhirjain.info/).], about wanting to be a writer for as long as I can remember, was carefully noted --- and magically my service responsibilities would end up being related to my childhood dream. A few days after I joined, I met [Achal Mehra](https://www.linkedin.com/in/achal-mehra-13037931/), who introduced me to [_Connections_](https://iitgn.ac.in/about/newsletter): a four-page newsletter that went places every quarter. In my mind, that conversation kickstarted my collaboration with what everyone fondly calls "comms". Seven years later, I'm here to report that the journey has been fun and fulfilling in equal measure.
+
+Through this post, I'd like to introduce you to the comms team: if you have been to IITGN for an event, read about us in the press, have recieved a newsletter from us, visited our website, or followed our social media: these are the folks who work behind the scenes on these fronts. Being a part of this gang has been a huge inspiration: everyone is talented but always willing to learn; their hard work is driven by a sense of ownership; and there's plenty of wit to help beat the heat :)
+
+Here's collection of some randomly chosen memories: my hat-tip to a stellar team.
+
+![The External Communications Team. From left to right: Hatim, Dilip, Tej, Apeksha, Dhara, Divyangi, Yours Truly, Chandni, Vandana, Shivangi, Gaurav, and Devarsh.](1.jpg)
+
+
+## Hatim
+
+[Hatim](https://www.linkedin.com/in/hatimsham/) joined us in the summer of 2018 and worked with us for four years. This summer, he moved on to join the design unit at [ISDM](https://www.isdm.org.in/team) as a Graphic Designer and Video Editor.
+
+Hatim has had a creative flair from the get go. He's been a part of several exciting projects, including being the person [behind the visuals](https://www.facebook.com/hatimsham/blog/pfbid02hWtj37tfFBSZiWmbe5yXTALMbDpG41YkGWtWZa4kxr25dysYdHnEjxZQMH6y5HcTl) for Alok Kanungo's book, _Glass Crafts in Northern India_. Also, [here's a cool trailer](https://twitter.com/iitgn/status/1285917964059869184) he put together very quickly for the ACM-W India Grad Cohort that I was involved in organizing in 2020.
+
+
+## Dilip
+
+[Dilip](https://www.linkedin.com/in/dilip-kashyap-49aaaaa0/) joined us in the summer of 2018. He had a distinct passion for developing mobile and web applications, and indeed, he's been a huge asset to the web vertical of the team. He's been relentless in learning new things and has been [writing on Medium](https://dilipkashyap15.medium.com/) too.
+
+When we were organizing the ACM-India Annual event and the team was freaking out over having upwards of 1000 registrations, Dilip wrote a mobile app for us --- literally overnight --- which allowed us to send all participants a QR code that they simply had to show to get through physical registration. It saved us a ton of time. You can find out more about Dilip [here](https://dilipkashyap07.github.io/).
+
+
+## Tej
+
+[Tej](https://www.linkedin.com/in/tej-bahadur-gurung-8b94232a/) joined us in the winter of 2016 as a web developer and has been my officemate. Tej is among the first points of contact for all new faculty at IITGN: their institutional profile pages are set up even before they actually set foot on campus. Tej's name is synonymous with "website". If anyone needs one done, whether it's for their lab, or an event, he's always been an email away. True to an appropriate mispronouciation of his name^[Tez = fast in Hindi], Tej has remarkable turnaround times, and seems to get things done as fast as you can spell them out.
+
+One of my most memorable projects with Tej (along with Dilip, Divyangi, and the rest of the team) is the revamp of the main IITGN website. We went from this:
+
+![The old IITGN website, [here](https://legacy.iitgn.ac.in).](old.png){width=70%}
+
+to this:
+
+![The current IITGN website, [here](https://www.iitgn.ac.in).](new.gif){width=70%}
+
+in about a year. Despite several very well-intended warnings about how crazy this was, the team picked up the project with cautious courage, and pulled it off. I think I can say with some confidence that the IITGN website is easy on the eyes, and things are not hard to find.
+
+## Apeksha
+
+[Apeksha](https://www.linkedin.com/in/srivastava-apeksha/) joined us in the summer of 2019, just on the heels of completing her MTech in Biological Engineering at IITGN, and stayed with the team for a year. At the time of joining, she was an avid consumer of popular science material, and aspired to make the research at IITGN more broady accessible with her writing. She was a freelance writer already, and was looking for an opportunity to spend some time writing full-time. Her stint with us resulted in a number of articles, and her growth during the time has been remarkable. You can find her writing on [her Medium blog](https://medium.com/@apeksha.0503).
+
+The ACM-W India Grad Cohort event we did in 2020 was a virtual one, and in the tradition of Grad Cohorts, was not recorded. I am grateful that Apeksha stepped up at the time, offered to attend all the sessions, and [wrote](https://medium.com/@apeksha.0503/the-acm-w-grad-cohort-2020-women-conquering-computing-online-ca085623e396) [up](https://medium.com/@apeksha.0503/grad-cohort-2020-day-1-of-the-women-virtual-workshop-in-computing-opens-with-a-bang-56407c113ad) [comprehensive](https://medium.com/@apeksha.0503/acm-w-grad-cohort-2020-day-2-a-perfect-combo-of-motivation-and-quality-advice-from-women-leaders-3f2c629e05e5) [summaries](https://medium.com/@apeksha.0503/day-3-acm-w-grad-cohort-2020-concludes-with-strong-networking-opportunities-and-professional-bc8c78efbc33).
+
+She has now joined the Ph.D. program in the Humanities and Social Sciences and is currently researching cognitive aspects of science communication with [Frederick Coolidge](https://en.wikipedia.org/wiki/Frederick_L._Coolidge.).
+
+## Dhara
+
+[Dhara](https://www.linkedin.com/in/dhara-vora-1019/) joined us in the summer of 2018, and immediately got to work on managing our social media channels. She also streamlined the process of collecting information: a lot of what we do revolves around robust archival, and IITGN being a happening place does not make this easy! We get dozens of emails every day announcing events of varying scales, updates of various kinds.
+
+Anticipating that the volume would only get worse, we devised a system for manually cataloging every bit of news in a bunch of Airtable bases. The long-term vision was that the Airtable API exposes this data to anyone who needs it: the web team could draw from it and filter appropriately to display upcoming events, an archival team could write a report generating app that used this as the backend, and so forth. We even had a web app developed by a team of undergraduates that pulled data from these bases to show off upcoming events on a big screen.
+
+Dhara now manually curates information from these databases and runs a weekly internal newsletter collating what's happened and what's coming up at IITGN: this has been a major value addition for many. She also serves up the raw data needed for our public [quarterly newsletter](https://iitgn.ac.in/about/newsletter) and [annual reports](https://iitgn.ac.in/about/annualreports) based on this system, which saves everyone a lot of time. Apart from all of this, she is in the driver's seat for all our [major](https://twitter.com/iitgn) [social](https://www.facebook.com/iitgn.official) [media](https://www.linkedin.com/school/indian-institute-of-technology-gandhinagar-iitgn-/) [channels](https://www.instagram.com/iit_gandhinagar/), and then some... and magically manages to stay on top of everything. You can [find her writing on Medium](https://medium.com/@voradhara46).
+
+
+## Divyangi
+
+[Divyangi](https://www.linkedin.com/in/divyangi-chaudhari-404115140/) joined us in the summer of 2018 and worked with us for three years until the summer of 2021. She was a wizard when it came to scripting for automating tasks, and quickly became the go-to person for departments who were looking to improve their workflows.
+
+IITGN runs on the Google ecosystem. Divyangi figured out several nice ways of bringing data from spreadsheets to frontends, generating reports, and so forth. She even ran a workshop on Google scripts and related tools as a part of an initiative coordinated by our Staff Development Cell.
+
+Among the many projects Divyangi was involved in, one of my favorites was the backend for our rather popular [Summer Research Internship Program](https://srip.iitgn.ac.in/). The website is powered by WordPress, and provides various interfaces for both interns and mentors to keep track of their applications during the application phase (this runs into tens of thousands of records), and progress during the internship (updates from interns and feedback from mentors are all managed from here). Divyangi, together with Dilip, deeply customized the WordPress instance to provide a number of features that help with running a large-scale program smoothly, with most of the tedious tasks completely automated.
+
+## Chandni
+
+Chandni joined us in the summer of 2019 for a year. She was already a very talented photographer at the time of joining us. As our events and activities grew in number and scale, we found very valuable support in Chandni's presence. Check out her [Instagram](https://www.instagram.com/visi_lens/) here!
+
+![A sample of Chandni's photography](chand.png)
+
+
+## Vandana
+
+[Vandana](https://www.linkedin.com/in/vandanay/) joined us in the summer of 2017 in the role of a Communications and Media Officer for a year. During this time, she was working closely with local press and media, and ensuring that our stories are filed with them on a regular basis.
+
+Vandana was already passionate about writing and had a keen eye for detail. She filled an important void at the time she joined and immediately setup various important foundations in the context of this role. She expanded our style guide, made a press kit, and developed a starting database of journalists that we could work with: these are all tools that the whole content team uses regularly to this day.
+
+Her spirit of volunteerism meant that a lot of our content got reviewed and improved across the board: on the website, on our brochures, and so forth. This was also the time when we launched what I think is our best-kept secret: IITGN's [news blog](https://news.iitgn.ac.in). Vandana, along with the rest of the team, setup a careful pipeline to ensure that everything we capture across press and social media gets a permanent home on the blog. She continues to pitch in remotely, even after moving on from her onsite role with us on campus.
+
+## Shivangi
+
+[Shivangi](https://www.linkedin.com/in/shivangi-bhatt-365b4a38/) joined us in the summer of 2018 in the role of a Communications and Media Officer, picking up from where Vandana left off. She has been synonymous with media and press at IITGN, and is currently our main interface with the press. She has substantially expanded on our network of partners in press, and ensures that we have the visibility we deserve in the local and national news, and even beyond. She is especially diligent about ensuring that regionally-focused news is appropriately translated in the local languages whenever appropriate, a widely appreciated effort.
+
+Shivangi's style has been remarkably proactive: if anything at IITGN is newsworthy, she makes sure it's covered. She draws on her substantial experience in the field to bring nuanced insights to the table, and these have served us very well in our overall communications and outreach strategy.
+
+Beyond coordinating stories for the press, Shivangi also comprehensively tracks IITGN's presence in the news and other public domains, is closely invovled in the production of the [quarterly newsletter](https://iitgn.ac.in/about/newsletter) and [annual reports](https://iitgn.ac.in/about/annualreports), and our social media activities as well. Shivangi is, unsurprisingly, an amazing writer, and [here's a performance of hers](https://www.facebook.com/shivangi.bhatt.501/blog/pfbid0CB5AGAkotx6cuXnYdNKGqVWc9jE7p3DrodzKTYGGDymSDWC4fxCJNer6bUrLCpJol) in a SDC event that was among my favorites.
+
+
+## Gaurav
+
+[Gaurav](https://www.linkedin.com/in/gauravvipul/) has been around for longer than I have, and he is a founding member of the team. He is among the most versatile people I know: not only does the scope of his work at IITGN go well beyond communications, even within communications his skills span a very wide range: he's behind the camera, he's the person behind the design and layouts for some of our best print collaterals, he's directed and produced a number of videos, and I could go on and on.
+
+I've freely relied on his mentorship: much of the growth that has happened within the team, especially in terms of creative efforts, is thanks to Gaurav's experience and guidance.
+
+If you pick up any of our booklets, there's a good chance that Gaurav has been involved in engineering the layout and design. Among them, I'll single out a couple for you to sample: the _[World Class Faculty](https://iitgn.ac.in/assets/pdfs/brochures/faculty-brochure.pdf)_ brochure looks especially lovely in print, and the [10 on 10](https://sites.iitgn.ac.in/10/index.php) brochure has a bold aesthetic that was a crowd favorite when it was released for our 10-year celebration.
+
+
+## Devarsh
+
+[Devarsh](https://www.instagram.com/dev_barbhaya/) joined us in the summer of 2017, with a background in creative film-making and theatre. He quickly became the go-to person when it came to anything to do with video or photography. Over the years here, he's grown leaps and bounds in his craft and understanding of all aspects of the process --- both work that happens on the field and in post.
+
+Our YouTube presence was in its nascent stages when Devarsh joined. He's single-handedly worked on [our channel](https://www.youtube.com/channel/UCbOCAa_fRS1qEOknCmEHzVw) in mission mode from the get go, and it is largely thanks to his efforts that we have a fairly systematic video respository of most major events and talks on campus.
+
+Devarsh has been involved in several memorable projects. Here's [a video](https://www.youtube.com/embed/lZSAkpjsyZs) that he shot for our first virtual convocation, which also happened to be among the first virtual convocation events to be held in India (as far as we know).
+
+## Nostalgia
+
+Some of the early members of the team are not pictured. Apart from everyone above, I had the good fortune to have worked with: Ritu (among other things, was the curator for all the early editions of the quarterly newsletter, _Connections_, and our annual reports), Dayanand (our first communications and media officer), Maria (our first social media intern), and Khushbu (who took over from Maria and preceded Dhara on managing social media).
+
+It would be remiss of me to not give a shout out to the faculty support we have enjoyed over the years. Several colleagues have played major roles in helping out on all aspects of our responsbilities. A special thanks to Achal Mehra, who brought extensive experience to the table, and has been forever generous with his time and advice, and [Vasco Trigo](https://twitter.com/iitgn/status/1163406174626050048), whose inputs for the whole team were extremely timely and valuable.
+
+I'll also take this opportunity to thank friends at the Communications department at Duke University --- they hosted us in the very early days, and their detailed and candid tour of various operational aspects was massively helpful in setting up a lot of the foundations back here.
+
+I walked into this gig more or less by accident. I should confess here that I didn't have a 5-year vision from which I could work backwards to nicely chunked milestones. There were no OKRs or KPIs or whatever else the pros do. A few times, it's occurred to us that we should have targets, strategies, and systems^[Most people at IITGN know by now that ambushing me in a corridor is more effective than email, and meanwhile, the team gets things done by some magic that remains a mystery to me.]. While we never articulated any as far as I can remember, I think we did have a tacitly shared goal: it was to ensure that everyone got what they needed from comms, and that we didn't make any mistake twice. My biases notwithstanding, I would say we have largely succeded :)
+
+My time with this team remains special forever.
diff --git a/sites/art/src/content/art/comms/new.gif b/sites/art/src/content/art/comms/new.gif
new file mode 100644
index 0000000..00761d1
Binary files /dev/null and b/sites/art/src/content/art/comms/new.gif differ
diff --git a/sites/art/src/content/art/comms/new.png b/sites/art/src/content/art/comms/new.png
new file mode 100644
index 0000000..e4c0600
Binary files /dev/null and b/sites/art/src/content/art/comms/new.png differ
diff --git a/sites/art/src/content/art/comms/old.png b/sites/art/src/content/art/comms/old.png
new file mode 100644
index 0000000..0f58d8f
Binary files /dev/null and b/sites/art/src/content/art/comms/old.png differ
diff --git a/sites/art/src/content/art/communication-complexity-equality/index.md b/sites/art/src/content/art/communication-complexity-equality/index.md
new file mode 100644
index 0000000..dd535d2
--- /dev/null
+++ b/sites/art/src/content/art/communication-complexity-equality/index.md
@@ -0,0 +1,16 @@
+---
+title: "On the Communication Complexity of Equality"
+description: "These are some quick sketchnotes based on this lecture by Ryan O’Donnell, a part of the playlist for the awesome CS Theory Toolkit course. You can walk through the arguments bel..."
+pubDate: "2021-10-04"
+authorName: "Neeldhara"
+sourceCategories: ["sketchnotes", "lecturenotes"]
+sourcePath: "communication-complexity-equality/index.qmd"
+---
+
+These are some quick sketchnotes based on  [this lecture](https://www.youtube.com/watch?v=orOJRhlqrvk) by [Ryan O’Donnell](https://www.cs.cmu.edu/~odonnell/), a part of the  [playlist](https://www.youtube.com/watch?v=prI35GmCon4&list=PLm3J0oaFux3ZYpFLwwrlv_EHH9wtH6pnX) for the awesome [CS Theory Toolkit](https://www.diderot.one/course/28/) course. You can walk through the arguments below.
+
+<iframe src="https://slides.com/neeldhara/deck-85ae95/embed?style=transparent&byline=hidden" width="795" height="420" title="Communication Complexity of Equality" scrolling="no" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe>
+
+I should mention that while the [Schwartz-Zippel-DeMillo-Lipton lemma](https://rjlipton.wpcomstaging.com/2009/11/30/the-curious-history-of-the-schwartz-zippel-lemma/) is invoked in the notes below, one could make do with just the fact that over any field $F$, any degree $n$ polynomial has at most $n$ roots, as pointed out by [@dsivakumar](https://twitter.com/dsivakumar) — thanks!
+
+<blockquote class="twitter-tweet"><p lang="en" dir="ltr">In the fourth slide from the end, why [DeMillo--Lipton]--Schwartz--Zippel Lemma? You only need that number of roots of a polynomial (over Z mod q) of degree n is no more than n. You don&#39;t need D-L/S/Z, which gives a general version for multivariate polynomials, right?</p>&mdash; D. Sivakumar (@dsivakumar) <a href="https://twitter.com/dsivakumar/status/1269351801108623360?ref_src=twsrc%5Etfw">June 6, 2020</a></blockquote>
diff --git a/sites/art/src/content/art/generative-art-p5js.md b/sites/art/src/content/art/generative-art-p5js.md
deleted file mode 100644
index ccfa3e7..0000000
--- a/sites/art/src/content/art/generative-art-p5js.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "Generative Art with p5.js: Creating Beauty from Mathematics"
-description: "Exploring the intersection of code and creativity through generative art experiments."
-pubDate: "Feb 18 2024"
-image: "https://images.unsplash.com/photo-1561070791-2526d30994b5?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Generative Art with p5.js: Creating Beauty from Mathematics
-
-Code becomes canvas when mathematics meets creativity.
-
-## Today's Creation: Perlin Noise Flows
-
-```javascript
-for (let particle of particles) {
-  let angle = noise(particle.x * 0.01, particle.y * 0.01, frameCount * 0.001) * TWO_PI;
-  particle.velocity = p5.Vector.fromAngle(angle);
-  particle.update();
-  particle.draw();
-}
-```
-
-## The Magic of Randomness
-
-Controlled randomness creates organic patterns. Perlin noise gives us randomness with continuity - nature's own algorithm.
-
-## Parameters as Paintbrushes
-
-- Noise scale: Changes pattern density
-- Particle count: Affects texture
-- Color mapping: Sets the mood
-
-## The Joy of Accidents
-
-The best discoveries come from "mistakes" - a typo that creates unexpected beauty, a parameter pushed to extremes.
-
-## Share Your Creations
-
-Art is meant to be shared. Post your generative experiments and let's inspire each other.
diff --git a/sites/art/src/content/art/indiamini-crosswords/collage.png b/sites/art/src/content/art/indiamini-crosswords/collage.png
new file mode 100644
index 0000000..b9aee40
Binary files /dev/null and b/sites/art/src/content/art/indiamini-crosswords/collage.png differ
diff --git a/sites/art/src/content/art/indiamini-crosswords/hazel-01.png b/sites/art/src/content/art/indiamini-crosswords/hazel-01.png
new file mode 100644
index 0000000..8e6cf63
Binary files /dev/null and b/sites/art/src/content/art/indiamini-crosswords/hazel-01.png differ
diff --git a/sites/art/src/content/art/indiamini-crosswords/hazel-02.png b/sites/art/src/content/art/indiamini-crosswords/hazel-02.png
new file mode 100644
index 0000000..a17a42d
Binary files /dev/null and b/sites/art/src/content/art/indiamini-crosswords/hazel-02.png differ
diff --git a/sites/art/src/content/art/indiamini-crosswords/index.md b/sites/art/src/content/art/indiamini-crosswords/index.md
new file mode 100644
index 0000000..420bf64
--- /dev/null
+++ b/sites/art/src/content/art/indiamini-crosswords/index.md
@@ -0,0 +1,116 @@
+---
+title: "Creating a Gallery of Solved Crosswords"
+description: "H/T Manu: I've discovered the India Mini Crossword series and it's a great two-to-five minute thing to solve every morning! Here's a little workflow I cobbled together to genera..."
+pubDate: "2024-05-10"
+authorName: "Neeldhara"
+sourceCategories: ["workflows"]
+sourcePath: "indiamini-crosswords/index.qmd"
+---
+
+H/T [Manu](https://twitter.com/mnwsth/status/1788781998904914215): I've discovered the [India Mini Crossword series](https://indiamini.in/play/) and it's a great two-to-five minute thing to solve every morning! Here's a little workflow I cobbled together to generate this collage of solved crosswords in [Obsidian](https://obsidian.md/):
+
+![Indiamini Crossword Solves Collage](collage.png)
+
+In practice, after the one-time setup I describe here, all I do after solving the crossword is print it and save the PDF to a folder called `Notes/`. The rest is automatic.
+
+To begin with, I have [Hazel](https://www.noodlesoft.com/) monitor the `Notes/` folder and run this rule:
+
+![Hazel Rule (Part 1)](hazel-01.png)
+
+All this does is checks if a PDF file has been added to the root level of the `Notes/` folder which has the string `Welcome to the India Mini crossword!`. It then pulls out the date from the file and pushes it into a date-based subfolder; e.g, if the crossword was for the 10th of May, the PDF file moves to the folder `Notes/2024/05/10/`. This is nice because even if I miss a day and solve something later, simply saving the file will still auto-file it in the correct directory.
+
+Next up, there is a second rule:
+
+![Hazel Rule (Part 2)](hazel-02.png)
+
+which processes the PDF file by extracting an image that contains the solved crossword. The actual work is carried out by this shell script, written mostly by chatGPT, complete with hard-coded paths:
+
+```bash
+#!/bin/bash
+
+# Extract the first page
+/usr/local/bin/pdftk /Users/neeldhara/Library/CloudStorage/Dropbox/Notes/$1/indiamini-crossword.pdf cat 1 output /Users/neeldhara/Library/CloudStorage/Dropbox/Notes/$1/first_page.pdf
+
+echo /Users/neeldhara/Library/CloudStorage/Dropbox/Notes/$1/indiamini-crossword.pdf
+
+# Convert the first page to a PNG
+/opt/homebrew/bin/convert -density 300 -quality 100 /Users/neeldhara/Library/CloudStorage/Dropbox/Notes/$1/first_page.pdf /Users/neeldhara/Library/CloudStorage/Dropbox/Notes/$1/first_page.png
+
+# Get the height and width of the image
+height=$(/opt/homebrew/bin/identify -format "%h" /Users/neeldhara/Library/CloudStorage/Dropbox/Notes/$1/first_page.png)
+width=$(/opt/homebrew/bin/identify -format "%w" /Users/neeldhara/Library/CloudStorage/Dropbox/Notes/$1/first_page.png)
+
+# Calculate the half height and width
+half_height=$((height/2))
+half_width=$((width/2+5))
+
+# Crop the image to the top right half
+/opt/homebrew/bin/convert /Users/neeldhara/Library/CloudStorage/Dropbox/Notes/$1/first_page.png -crop 1100x1100+${half_width}+315 /Users/neeldhara/Library/CloudStorage/Dropbox/Notes/$1/indiamini-crossword.png
+
+# Delete intermediate files
+rm /Users/neeldhara/Library/CloudStorage/Dropbox/Notes/$1/first_page.png
+rm /Users/neeldhara/Library/CloudStorage/Dropbox/Notes/$1/first_page.pdf
+```
+
+I finally have a very simple [Keyboard Maestro](http://www.keyboardmaestro.com/) macro that runs every morning at 7AM --- except Sundays, because the Sunday crossword is not a mini :) --- to create the crossword note in my Obsidian vault in a date-based folder:
+
+![KM Macro](km-macro.png)
+
+The crossword note template is very minimal:
+
+```markdown
+---
+title: India Mini Crossword · <% tp.date.now("YYYY") %>-<% tp.date.now("MM") %>-<% tp.date.now("DD") %>
+tags:
+  - kw/c/crossword
+  - kw/i/indiamini
+  - puzzles/indiamini-crossword
+asset: file:///Users/neeldhara/Library/CloudStorage/Dropbox/Notes/<% tp.date.now("YYYY") %>/<% tp.date.now("MM") %>/<% tp.date.now("DD") %>/indiamini-crossword.pdf
+---
+
+
+![Crossword](file:///Users/neeldhara/Library/CloudStorage/Dropbox/Notes/<% tp.date.now("YYYY") %>/<% tp.date.now("MM") %>/<% tp.date.now("DD") %>/indiamini-crossword.png)
+```
+
+The [Templater plugin for Obsidian](https://github.com/SilentVoid13/Templater) ensures that the dates expand correctly at the time the note is created. You could instead run a shell script to just generate these notes for all dates in advance, but I like this because the KM prompt reminds me to do the crossword :)
+
+The individual crossword file simply shows the PNG file generated by the Hazel rule. I might eventually add solve times to the frontmatter. For the collage, I use this dataview query in a separate note:
+
+```javascript
+console.log('Fetching pages from "Notes" with specific tag...');
+
+const assets = dv.pages('"Notes"')
+  .where(p => p.tags?.includes("puzzles/indiamini-crossword") && p.asset)
+  .map(page => {
+    // Replace .pdf with .png in the asset path
+    const pngAsset = page.asset.replace('.pdf', '.png');
+    console.log(`Found page: ${page.file.path} with asset: ${pngAsset}`);
+    return {
+      file: page.file.link,
+      asset: pngAsset // Now the asset points to a .png file instead of a .pdf
+    };
+  });
+
+dv.paragraph(`Total images found: ${assets.length}`);
+assets.sort();
+
+let fullstring = "";
+
+if (assets.length === 0) {
+  dv.paragraph("No assets found. Check the folder, tags, and frontmatter.");
+} else {
+  assets.forEach((item, index) => {
+    fullstring += `![|230](${item.asset})&nbsp;&nbsp;&nbsp;`;
+    if ((index + 1) % 3 === 0) { // After every third image
+      fullstring += '\n'; // Append a line break
+    }
+  });
+}
+
+
+dv.paragraph(fullstring);
+```
+
+The [media grid snippet for Obsidian](https://github.com/zremboldt/obsidian-media-grid) gets the grid alignment going for the images.
+
+And that's it!
diff --git a/sites/art/src/content/art/indiamini-crosswords/indiamini.hazelrules b/sites/art/src/content/art/indiamini-crosswords/indiamini.hazelrules
new file mode 100644
index 0000000..5202850
Binary files /dev/null and b/sites/art/src/content/art/indiamini-crosswords/indiamini.hazelrules differ
diff --git a/sites/art/src/content/art/indiamini-crosswords/km-macro.png b/sites/art/src/content/art/indiamini-crosswords/km-macro.png
new file mode 100644
index 0000000..5cd5871
Binary files /dev/null and b/sites/art/src/content/art/indiamini-crosswords/km-macro.png differ
diff --git a/sites/art/src/content/poetry/algorithms-in-verse.md b/sites/art/src/content/poetry/algorithms-in-verse.md
deleted file mode 100644
index 4ad1e1d..0000000
--- a/sites/art/src/content/poetry/algorithms-in-verse.md
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title: "Algorithms in Verse: Bubble Sort Sonnet"
-description: "Classic algorithms reimagined as poetry - where code meets iambic pentameter."
-pubDate: "Feb 22 2024"
-image: "https://images.unsplash.com/photo-1455390582262-044cdead277a?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Algorithms in Verse: Bubble Sort Sonnet
-
-## Bubble Sort: A Sonnet
-
-```
-Compare adjacent elements in pairs,
-If order's wrong, then swap them into place.
-Through all the list this simple rule declares:
-The largest bubbles up to find its space.
-
-Again we start, but now one less to check,
-The second largest finds its rightful home.
-Each pass through makes the chaos less a wreck,
-Until at last no elements must roam.
-
-Though simple in its elegance and grace,
-And easy for beginners to perceive,
-In practice, it's too slow to win the race—
-O(n²) we sadly must believe.
-
-But beauty lies in simplicity's pure art,
-The bubble sort still teaches at the start.
-```
-
-## The Challenge
-
-Can you write Quicksort as a limerick? Or Binary Search as free verse?
-
-## Why This Matters
-
-Poetry forces us to find the essence of an algorithm. The constraint reveals understanding.
diff --git a/sites/art/src/content/poetry/code-haikus.md b/sites/art/src/content/poetry/code-haikus.md
deleted file mode 100644
index 6af408a..0000000
--- a/sites/art/src/content/poetry/code-haikus.md
+++ /dev/null
@@ -1,56 +0,0 @@
----
-title: "Code Haikus: Programming in 5-7-5"
-description: "Expressing programming concepts through the constrained beauty of haiku."
-pubDate: "Jan 30 2024"
-image: "https://images.unsplash.com/photo-1481627834876-b7833e8f5570?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Code Haikus: Programming in 5-7-5
-
-The constraint of haiku forces clarity. Here are programming concepts distilled to their essence.
-
-## On Recursion
-
-```
-Function calls itself
-Smaller problems, same pattern  
-Base case stops the loop
-```
-
-## On Debugging
-
-```
-Print statements bloom wild
-Binary search through the code
-Bug reveals itself
-```
-
-## On Optimization
-
-```
-O(n squared) crawls
-Refactor to n log n
-Time complexity
-```
-
-## On Git Merge Conflicts
-
-```
-<<<<<<< HEAD
-Your changes, their changes clash
-Resolution waits
-```
-
-## On Learning
-
-```
-Stack Overflow searched
-Tutorial incomplete
-Understanding dawns
-```
-
-## Your Turn
-
-Write a haiku about your coding experience today. The constraint reveals truth.
diff --git a/sites/art/src/content/puzzles/100-prisoners.mdx b/sites/art/src/content/puzzles/100-prisoners.mdx
deleted file mode 100644
index 3ff2b3c..0000000
--- a/sites/art/src/content/puzzles/100-prisoners.mdx
+++ /dev/null
@@ -1,183 +0,0 @@
----
-title: "The 100 Prisoners Problem: A Beautiful Puzzle in Probability"
-description: "An interactive exploration of one of the most counterintuitive puzzles in probability theory, where 100 prisoners can escape with over 30% chance using a clever strategy."
-pubDate: "Oct 13 2025"
-image: "https://images.unsplash.com/photo-1589829545856-d10d557cf95f?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-import PrisonerGameSimulator from '@/components/problems/PrisonerGameSimulator.tsx';
-import ProbabilityChart from '@/components/problems/ProbabilityChart.tsx';
-import PermutationExplorer from '@/components/problems/PermutationExplorer.tsx';
-import StrategyComparison from '@/components/problems/StrategyComparison.tsx';
-
-# The 100 Prisoners Problem
-
-Imagine 100 prisoners, numbered 1 to 100, face an unusual challenge. In a room are 100 boxes, also numbered 1 to 100. Inside each box is a randomly assigned number from 1 to 100 (each number appearing exactly once). The prisoners must find their own number by opening boxes, but here's the catch: **each prisoner can open only 50 boxes**.
-
-The prisoners can devise a strategy beforehand, but once the challenge begins, they cannot communicate. If **all 100 prisoners** find their number, everyone goes free. If even one prisoner fails, all remain imprisoned.
-
-What's the best strategy? And what are the odds of success?
-
-## Try It Yourself!
-
-Before we dive into the mathematics, let's experience the problem firsthand. Below is a simulator where you can play the game yourself. Choose the number of prisoners (between 5 and 100), and then try to help each prisoner find their number by clicking on boxes.
-
-<PrisonerGameSimulator client:only="react" />
-
----
-
-## The Naive Strategy
-
-The most obvious approach is for each prisoner to simply open 50 random boxes. This seems reasonable, but the probability of success is dismal.
-
-For any single prisoner, the probability of finding their number in 50 random boxes out of 100 is exactly 1/2. Since all 100 prisoners must succeed, and their outcomes are independent under random selection, the probability that everyone succeeds is:
-
-$$P(\text\{success\}) = \left(\frac\{1\}\{2\}\right)^\{100\} \approx 7.9 \times 10^\{-31\}$$
-
-That's essentially zero! You're more likely to win the lottery while being struck by lightning... multiple times.
-
-### Naive Strategy: Probability vs Number of Prisoners
-
-Watch how the probability of success plummets as we increase the number of prisoners:
-
-<ProbabilityChart strategy="naive" client:only="react" />
-
-As you can see, even with just 10 prisoners, the probability drops to about 0.1%. With 100 prisoners, it's practically impossible.
-
----
-
-## The Clever Strategy: Following the Loops
-
-Here's where mathematics reveals something beautiful. Instead of opening random boxes, each prisoner should follow a simple rule:
-
-1. **Start by opening the box with your own number**
-2. **Look at the number inside that box**
-3. **Open the box with that number next**
-4. **Continue following this chain**
-
-Why does this work? The key insight involves understanding permutations and cycles.
-
-### Understanding Cycles in Permutations
-
-When we randomly assign 100 numbers to 100 boxes, we're creating a **permutation** of the numbers 1 through 100. Every permutation can be decomposed into **cycles**.
-
-For example, if:
-- Box 1 contains number 4
-- Box 4 contains number 7
-- Box 7 contains number 1
-
-Then we have a cycle: 1 -> 4 -> 7 -> 1
-
-Let's explore this with smaller numbers:
-
-<PermutationExplorer client:only="react" />
-
-The interactive explorer above lets you:
-- Generate all permutations for small values of *n* (3, 4, or 5)
-- See both standard notation and cycle notation
-- Filter permutations that have at least one "long cycle" (longer than *n*/2)
-- Understand why long cycles matter
-
-### Why This Strategy Works
-
-Here's the crucial insight: **A prisoner succeeds if and only if they are in a cycle of length ≤ 50**.
-
-When prisoner k follows the loop strategy:
-1. They start at box k
-2. They follow a path through boxes determined by the permutation
-3. This path forms a cycle that eventually leads back to box k
-4. If this cycle has length ≤ 50, they'll find their number within 50 opens
-
-The prisoners **all succeed** if and only if there is **no cycle longer than 50** in the permutation.
-
-### Calculating the Probability
-
-The probability that a random permutation of 100 elements has no cycle longer than 50 is:
-
-$$P(\text\{success\}) = 1 - \sum_\{k=51\}^\{100\} \frac\{1\}\{k\}$$
-
-Computing this sum:
-
-$$P(\text\{success\}) = 1 - \left(\frac\{1\}\{51\} + \frac\{1\}\{52\} + \cdots + \frac\{1\}\{100\}\right) \approx 0.3118$$
-
-That's over **31%**! This is astronomically better than the naive strategy's probability of essentially zero.
-
-### Loop Strategy: Probability vs Number of Prisoners
-
-<StrategyComparison client:only="react" />
-
-## The Mathematics Behind It
-
-### Why Does the Cycle Length Matter?
-
-In a permutation of n elements, prisoner i will find their number within k tries using the loop strategy if and only if i belongs to a cycle of length at most k.
-
-For n = 100 and k = 50:
-- The probability that a specific prisoner is in a cycle of length > 50 is: Σ(j=51 to 100) of 1/100
-- But we care about whether ANY prisoner is in such a cycle
-- The probability that NO cycle has length > 50 is: 1 - Σ(j=51 to 100) of 1/j
-
-### The Harmonic Series Connection
-
-As *n* approaches infinity, if each prisoner can open *n*/2 boxes, the probability of success approaches:
-
-The limit as n approaches infinity is: P_n = 1 - ln(2) ≈ 0.3069
-
-This beautiful result connects combinatorics, probability, and analysis through the harmonic series!
-
-### Optimality
-
-Remarkably, this loop-following strategy is **optimal**. No other strategy can achieve a higher probability of success. The proof involves showing that the problem reduces to avoiding long cycles in a random permutation, and the loop strategy is the unique way to leverage this structure.
-
----
-
-## Why This Problem is Beautiful
-
-The 100 prisoners problem is beloved by mathematicians because:
-
-1. **Counterintuitive Result**: The fact that 31% >> 0% is shocking. A seemingly hopeless problem becomes tractable with the right insight.
-
-2. **Deep Connection**: It connects permutation theory, probability, and the harmonic series in an elegant way.
-
-3. **Collaborative Success**: Unlike independent trials, the prisoners' fates are intertwined through the structure of the permutation.
-
-4. **Real-World Metaphor**: It illustrates how understanding underlying structure (cycles in permutations) can dramatically improve outcomes.
-
----
-
-## Variants and Extensions
-
-### What if prisoners can open k < n/2 boxes?
-
-As k decreases below n/2, the probability drops rapidly. The threshold at n/2 is special—it's where the strategy becomes remarkably effective.
-
-### What about communication?
-
-If prisoners could communicate between trials (but not during), they still can't improve the strategy. The beauty is that the strategy requires only coordination before any prisoner enters, not during.
-
-### The Malicious Director
-
-In an interesting variant, suppose the director can see the prisoners' strategy and arrange the boxes adversarially (not randomly). Can the director always force them to fail? Yes! The director can always create a single cycle of length n, guaranteeing failure.
-
----
-
-## Conclusion
-
-The 100 prisoners problem shows us that:
-- Mathematical structure can be hidden in apparent randomness
-- Clever strategies can overcome seemingly impossible odds
-- Group coordination can be more powerful than independent action
-- Beautiful mathematics often lies beneath simple-seeming puzzles
-
-The next time you face a problem that seems impossible, remember: there might be a hidden structure waiting to be discovered, turning hopeless odds into reasonable ones.
-
----
-
-## Further Reading
-
-- [Gál, A., & Miltersen, P. B. (2003). "The Cell Probe Complexity of Succinct Data Structures"](https://arxiv.org/abs/cs/0310027)
-- [Curtin, E., & Warshauer, M. (2006). "The Locker Puzzle"](https://www.jstor.org/stable/27642173)
-- [Wikipedia: 100 Prisoners Problem](https://en.wikipedia.org/wiki/100_prisoners_problem)
-
diff --git a/sites/art/src/content/puzzles/dynamic-programming-gems.md b/sites/art/src/content/puzzles/dynamic-programming-gems.md
deleted file mode 100644
index 79e68ea..0000000
--- a/sites/art/src/content/puzzles/dynamic-programming-gems.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "Dynamic Programming: Hidden Gems from Recent Contests"
-description: "Elegant dynamic programming problems that showcase beautiful techniques and insights."
-pubDate: "Jan 25 2024"
-image: "https://images.unsplash.com/photo-1509228468518-180dd4864904?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Dynamic Programming: Hidden Gems from Recent Contests
-
-These problems demonstrate the art of dynamic programming beyond standard patterns.
-
-## Problem 1: The Subsequence Symphony
-
-Given a string, find the number of subsequences that form palindromes of prime length.
-
-### Solution Insight
-
-The key is to maintain DP states for both position and palindrome center simultaneously. This reduces the state space from O(n³) to O(n²).
-
-## Problem 2: Graph Coloring with Constraints
-
-Color a graph such that no two adjacent vertices share a color, and the total number of color changes along any path is minimized.
-
-### The DP Formulation
-
-DP[node][color][changes] gives us the minimum cost. The trick is recognizing that we only need to track changes modulo 2.
-
-## Practice Makes Perfect
-
-These problems teach us that DP is as much about problem modeling as it is about computation.
diff --git a/sites/art/src/content/puzzles/four-aces-miracle.md b/sites/art/src/content/puzzles/four-aces-miracle.md
deleted file mode 100644
index a1710ab..0000000
--- a/sites/art/src/content/puzzles/four-aces-miracle.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "The Four Aces Miracle: A Self-Working Mathematical Marvel"
-description: "A card trick that teaches modular arithmetic and probability - perfect for the classroom."
-pubDate: "Jan 28 2024"
-image: "https://images.unsplash.com/photo-1529480384838-c1681c84aca5?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# The Four Aces Miracle: A Self-Working Mathematical Marvel
-
-This trick never fails to amaze students, and the mathematics behind it is even more amazing.
-
-## The Effect
-
-A spectator deals cards into four piles while making random choices. Impossibly, the four aces end up on top of each pile.
-
-## The Secret
-
-It's all about invariants and modular arithmetic. No sleight of hand required - pure mathematics does the magic.
-
-## The Method
-
-1. Pre-arrange the deck (the math determines the arrangement)
-2. Have the spectator deal following simple rules
-3. The aces appear automatically
-
-## The Mathematics
-
-The dealing process preserves certain positional invariants modulo 4. The initial arrangement ensures these invariants place the aces correctly.
-
-## Teaching Applications
-
-This trick demonstrates:
-- Modular arithmetic
-- Invariants in algorithms
-- Deterministic vs. random processes
-
-## The Bigger Lesson
-
-Mathematics can create experiences that feel like magic. And that feeling of wonder? That's what hooks students on math.
diff --git a/sites/art/src/content/puzzles/gilbreath-principle.md b/sites/art/src/content/puzzles/gilbreath-principle.md
deleted file mode 100644
index 92e229b..0000000
--- a/sites/art/src/content/puzzles/gilbreath-principle.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: "The Gilbreath Principle: When Chaos Creates Order"
-description: "A mathematical card principle that seems impossible but always works - perfect for teaching algorithms."
-pubDate: "Feb 15 2024"
-image: "https://images.unsplash.com/photo-1570543375343-63fe3d67761b?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# The Gilbreath Principle: When Chaos Creates Order
-
-Shuffle a deck in a specific way, and mathematical order emerges from apparent chaos.
-
-## The Phenomenon
-
-Arrange cards alternating red-black. Riffle shuffle. Now deal pairs - each pair has one red and one black card. Magic? No, mathematics.
-
-## Why It Works
-
-The riffle shuffle preserves local structure while appearing to randomize. The alternating pattern creates an invariant that survives the shuffle.
-
-## Classroom Implementation
-
-Students predict it won't work. When it does, they're hooked. "Why?" becomes the driving question.
-
-## The Deeper Lesson
-
-Not all randomness is truly random. Structure can hide in apparent disorder. This principle appears in:
-- Network protocols
-- Error-correcting codes  
-- Distributed systems
-
-## Beyond Cards
-
-The Gilbreath Principle teaches us to look for hidden invariants in complex systems.
diff --git a/sites/art/src/content/puzzles/graph-algorithms-assessment.md b/sites/art/src/content/puzzles/graph-algorithms-assessment.md
deleted file mode 100644
index 4c61fe2..0000000
--- a/sites/art/src/content/puzzles/graph-algorithms-assessment.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "Graph Algorithms: Assessment Highlights"
-description: "Interesting graph problems from recent course assessments with detailed solutions."
-pubDate: "Feb 28 2024"
-image: "https://images.unsplash.com/photo-1550751827-4bd374c3f58b?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Graph Algorithms: Assessment Highlights
-
-A collection of graph problems that test deep understanding rather than memorization.
-
-## The Bridge Detection Variant
-
-Find all edges whose removal increases the number of triangles in the graph.
-
-### Solution Approach
-
-Counter-intuitively, we need to count triangles that share exactly one edge with the candidate. The algorithm runs in O(m√m) time using careful enumeration.
-
-## Shortest Path with Wildcards
-
-Given a graph where some edge weights are variables, find assignments that minimize the longest shortest path.
-
-### Key Insight
-
-This reduces to a linear programming problem with interesting structure. The dual interpretation reveals connections to network flow.
-
-## Teaching Through Problems
-
-These problems help students see beyond standard algorithms to underlying principles.
diff --git a/sites/art/src/content/puzzles/ioi-2023-analysis.md b/sites/art/src/content/puzzles/ioi-2023-analysis.md
deleted file mode 100644
index 782177c..0000000
--- a/sites/art/src/content/puzzles/ioi-2023-analysis.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "IOI 2023: Breaking Down the Hardest Problems"
-description: "Deep analysis of the most challenging problems from the International Olympiad in Informatics 2023."
-pubDate: "Jan 20 2024"
-image: "https://images.unsplash.com/photo-1434030216411-0b793f4b4173?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# IOI 2023: Breaking Down the Hardest Problems
-
-The International Olympiad in Informatics continues to push the boundaries of algorithmic problem solving.
-
-## Problem: Soccer Stadium
-
-A geometric optimization problem disguised as dynamic programming. The key insight: think in terms of monotonic paths.
-
-### The Approach
-
-1. Transform the 2D problem into a 1D problem using clever observations
-2. Use convex hull optimization for the DP transitions
-3. Handle edge cases with careful implementation
-
-## Problem: Closing Time
-
-A tree problem requiring sophisticated data structures and careful analysis.
-
-### The Solution
-
-The trick is recognizing this as a centroid decomposition problem. Once you see it, the implementation follows naturally.
-
-## Lessons for Students
-
-These problems teach us:
-- Simple problems have elegant solutions
-- Complex problems require systematic decomposition
-- Implementation matters as much as algorithms
-
-## Practice Strategy
-
-Start with subtasks. Even partial solutions teach valuable lessons.
diff --git a/sites/art/src/content/puzzles/knights-tour-interactive.md b/sites/art/src/content/puzzles/knights-tour-interactive.md
deleted file mode 100644
index eec6960..0000000
--- a/sites/art/src/content/puzzles/knights-tour-interactive.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: "The Knight's Tour: An Interactive Exploration"
-description: "An interactive puzzle exploring the knight's tour problem with surprising mathematical connections."
-pubDate: "Jan 30 2024"
-image: "https://images.unsplash.com/photo-1528819622765-d6bcf132f793?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# The Knight's Tour: An Interactive Exploration
-
-Can a knight visit every square on a chessboard exactly once? This ancient puzzle hides deep mathematical structure.
-
-## The Basic Challenge
-
-Start with a 5×5 board. Can you find a knight's tour? What about one that returns to the starting square (a closed tour)?
-
-## Mathematical Beauty
-
-The problem connects to:
-- Hamiltonian paths in graphs
-- Warnsdorff's heuristic
-- Magic squares (surprisingly!)
-
-## The Algorithm
-
-The key insight: always move to the square with fewest onward moves. This simple heuristic works remarkably well.
-
-## Try It Yourself
-
-[Interactive board would go here - imagine clicking squares to build your tour]
-
-## Going Deeper
-
-For which board sizes do closed tours exist? The answer involves beautiful number theory.
diff --git a/sites/art/src/content/puzzles/projecteuler-favorites.md b/sites/art/src/content/puzzles/projecteuler-favorites.md
deleted file mode 100644
index 16988a9..0000000
--- a/sites/art/src/content/puzzles/projecteuler-favorites.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: "Project Euler: My Favorite Problems from 700+"
-description: "Curated problems from Project Euler that teach beautiful mathematical and algorithmic concepts."
-pubDate: "Feb 25 2024"
-image: "https://images.unsplash.com/photo-1635070041078-e363dbe005cb?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Project Euler: My Favorite Problems from 700+
-
-After solving 700+ Project Euler problems, these are the ones that changed how I think about mathematics and programming.
-
-## Problem 96: Su Doku
-
-Not just Sudoku solving - but solving 50 puzzles efficiently. The beauty is in combining constraint propagation with backtracking.
-
-## Problem 208: Robot Walks
-
-A counting problem that requires deep mathematical insight. The connection to complex numbers is unexpected and beautiful.
-
-## Problem 613: Pythagorean Ant
-
-Probability meets geometry in this elegant problem. The solution requires careful integration and surprising symmetry observations.
-
-## The Meta-Lesson
-
-Project Euler teaches you:
-- Mathematical intuition matters more than coding speed
-- There's always a clever approach
-- The journey matters more than the destination
-
-## Getting Started
-
-Don't aim for the leaderboard. Aim for understanding. Each problem is a teacher.
diff --git a/sites/art/src/content/puzzles/sudoku-variants.md b/sites/art/src/content/puzzles/sudoku-variants.md
deleted file mode 100644
index 1efd136..0000000
--- a/sites/art/src/content/puzzles/sudoku-variants.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-title: "Beyond Sudoku: Exploring Constraint Satisfaction Puzzles"
-description: "A journey through Sudoku variants and their algorithmic solutions."
-pubDate: "Feb 10 2024"
-image: "https://images.unsplash.com/photo-1580541631950-7282082b53ce?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Beyond Sudoku: Exploring Constraint Satisfaction Puzzles
-
-Sudoku is just the beginning. Let's explore variants that push the boundaries of logic puzzles.
-
-## Killer Sudoku
-
-Combine Sudoku with Kakuro - cages show sums, but no digit repeats within a cage.
-
-## Sandwich Sudoku
-
-The numbers outside show the sum of digits between 1 and 9 in that row/column. Simple rule, complex implications!
-
-## The Algorithm Connection
-
-These puzzles are constraint satisfaction problems. Techniques like arc consistency and backtracking with constraint propagation solve them efficiently.
-
-## Create Your Own
-
-What happens if we add chess knight move constraints? The design space is infinite!
diff --git a/sites/art/src/content/reflections/imposter-syndrome.md b/sites/art/src/content/reflections/imposter-syndrome.md
deleted file mode 100644
index e0a77e0..0000000
--- a/sites/art/src/content/reflections/imposter-syndrome.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: "Imposter Syndrome in Academia: A Confession"
-description: "An honest conversation about feeling like a fraud, even after years of success."
-pubDate: "Feb 25 2024"
-image: "https://images.unsplash.com/photo-1517048676732-d65bc937f952?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Imposter Syndrome in Academia: A Confession
-
-Even after publishing papers, winning grants, and teaching thousands of students, the voice whispers: "They'll find out you don't belong."
-
-## The Paradox
-
-The more you know, the more you realize you don't know. Expertise breeds humility, which feeds the imposter.
-
-## What Helps
-
-- Keeping a "wins" journal - evidence against the imposter
-- Mentoring others - seeing your knowledge help someone
-- Talking about it - you're not alone in this
-
-## The Silver Lining
-
-Maybe imposter syndrome keeps us humble, curious, and always learning. Maybe it's not a bug, but a feature.
-
-## Moving Forward
-
-I may never silence the voice completely. But I've learned to acknowledge it and keep going anyway.
diff --git a/sites/art/src/content/reflections/teaching-philosophy.md b/sites/art/src/content/reflections/teaching-philosophy.md
deleted file mode 100644
index fc1a0f2..0000000
--- a/sites/art/src/content/reflections/teaching-philosophy.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "On Teaching Algorithms: Lessons from a Decade"
-description: "Reflections on what works (and what doesn't) in computer science education."
-pubDate: "Jan 10 2024"
-image: "https://images.unsplash.com/photo-1509062522246-3755977927d7?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# On Teaching Algorithms: Lessons from a Decade
-
-Ten years of teaching has taught me more than any textbook could.
-
-## Start with Why
-
-Students don't care about O(n log n) until they understand why their code is slow. Real problems first, theory second.
-
-## The Power of Visualization
-
-Abstract concepts become concrete when visualized. Every algorithm should have a picture.
-
-## Failure is a Feature
-
-Let students struggle. The struggle is where learning happens. But know when to throw a lifeline.
-
-## Assessment Philosophy
-
-Test understanding, not memorization. Open-book exams with novel problems beat closed-book regurgitation every time.
-
-## The Joy of "Aha!" Moments
-
-There's no feeling quite like seeing a student's eyes light up when a concept clicks. That's why we do this.
diff --git a/sites/art/src/content/research/conference-highlights-2024.md b/sites/art/src/content/research/conference-highlights-2024.md
deleted file mode 100644
index 73b6741..0000000
--- a/sites/art/src/content/research/conference-highlights-2024.md
+++ /dev/null
@@ -1,34 +0,0 @@
----
-title: "SODA 2024: Algorithmic Breakthroughs"
-description: "A roundup of fascinating algorithmic results from SODA 2024, focusing on graph algorithms and optimization techniques."
-pubDate: "Jan 15 2024"
-image: "https://images.unsplash.com/photo-1509228468518-180dd4864904?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# SODA 2024: Algorithmic Breakthroughs
-
-The Symposium on Discrete Algorithms (SODA) 2024 brought together researchers from around the world to present cutting-edge algorithmic research. This post highlights some of the most exciting developments in graph algorithms and optimization.
-
-## Graph Algorithms Revolution
-
-### Dynamic Graph Coloring
-
-One of the standout papers introduced a breakthrough in dynamic graph coloring with polylogarithmic update time. The authors developed a novel data structure that maintains a proper vertex coloring while supporting edge insertions and deletions efficiently.
-
-The key insight was to combine randomized recoloring strategies with a carefully designed hierarchical decomposition of the graph. This allows for local updates that rarely propagate through the entire structure.
-
-## Approximation Algorithms
-
-### The Traveling Salesman Problem Revisited
-
-A surprising result showed that for graphs with bounded doubling dimension, we can achieve a (1+ε)-approximation for TSP in nearly linear time. This improves upon decades of previous work and opens new avenues for practical implementations.
-
-## Complexity Theory Connections
-
-The conference also featured several papers bridging the gap between pure algorithmic research and complexity theory. A particularly elegant result showed that certain graph problems believed to require quadratic time are equivalent under fine-grained reductions.
-
-## Looking Forward
-
-These results demonstrate that fundamental algorithmic problems still have room for improvement. The techniques developed here will likely influence algorithm design for years to come.
diff --git a/sites/art/src/content/research/distributed-algorithms.md b/sites/art/src/content/research/distributed-algorithms.md
deleted file mode 100644
index e577220..0000000
--- a/sites/art/src/content/research/distributed-algorithms.md
+++ /dev/null
@@ -1,34 +0,0 @@
----
-title: "Distributed Computing: Recent Advances"
-description: "Survey of recent developments in distributed algorithms from major conferences."
-pubDate: "Feb 20 2024"
-image: "https://images.unsplash.com/photo-1558618666-fcd25c85cd64?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Distributed Computing: Recent Advances
-
-The field of distributed computing has seen remarkable progress in recent years. This post surveys key results from PODC, DISC, and other major venues.
-
-## Consensus Protocols
-
-### Byzantine Agreement in Asynchronous Networks
-
-A breakthrough result achieves optimal resilience with expected constant rounds. The protocol uses cryptographic techniques combined with novel committee selection.
-
-## Distributed Graph Algorithms
-
-### Minimum Spanning Tree in the CONGEST Model
-
-New algorithms achieve near-optimal round complexity for MST construction. The approach uses sophisticated graph decomposition techniques.
-
-## Local Algorithms
-
-### The Power of Local Computation
-
-Recent work characterizes which problems admit constant-time local algorithms. The classification provides a complete picture for bounded-degree graphs.
-
-## Future Directions
-
-The intersection of distributed computing with machine learning presents exciting opportunities for both fields.
diff --git a/sites/art/src/content/research/git-automation.md b/sites/art/src/content/research/git-automation.md
deleted file mode 100644
index 2ae09cd..0000000
--- a/sites/art/src/content/research/git-automation.md
+++ /dev/null
@@ -1,54 +0,0 @@
----
-title: "Git Workflows That Save My Sanity"
-description: "Automation scripts and Git hooks that eliminate repetitive tasks and prevent common mistakes."
-pubDate: "Jan 22 2024"
-image: "https://images.unsplash.com/photo-1556075798-4825dfaaf498?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Git Workflows That Save My Sanity
-
-After years of Git mishaps, I've built workflows that prevent disasters and save hours weekly.
-
-## The Pre-commit Hook That Saves Embarrassment
-
-```bash
-#!/bin/bash
-# Check for debugging statements
-if grep -r "console.log\|debugger\|TODO" --include="*.js" .; then
-  echo "⚠️  Debugging statements found!"
-  exit 1
-fi
-```
-
-## Automatic Branch Naming
-
-```bash
-alias feature='git checkout -b feature/$(date +%Y%m%d)-$1'
-```
-
-Now `feature "user-auth"` creates `feature/20240122-user-auth`.
-
-## The Commit Message Template
-
-```
-[TYPE] Brief description
-
-Why:
-- Context for this change
-
-What:
-- Specific changes made
-
-Testing:
-- How to verify it works
-```
-
-## The Weekly Cleanup Script
-
-Deletes merged branches, prunes remotes, and garbage collects. Keeps the repo clean and fast.
-
-## ROI
-
-These automations save ~5 hours per week and countless prevented mistakes. The time invested in setting them up paid back in days.
diff --git a/sites/art/src/content/research/obsidian-academic.md b/sites/art/src/content/research/obsidian-academic.md
deleted file mode 100644
index 7e1c181..0000000
--- a/sites/art/src/content/research/obsidian-academic.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "Academic Writing with Obsidian and Pandoc"
-description: "A complete workflow for academic papers - from notes to publication-ready PDFs."
-pubDate: "Feb 12 2024"
-image: "https://images.unsplash.com/photo-1456324504439-367cee3b3c32?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Academic Writing with Obsidian and Pandoc
-
-Transform your scattered research notes into beautiful academic papers with this workflow.
-
-## The Setup
-
-- **Obsidian**: For note-taking and knowledge management
-- **Pandoc**: For document conversion
-- **LaTeX**: For typesetting
-- **Zotero**: For reference management
-
-## The Magic Command
-
-```bash
-pandoc paper.md \
-  --filter pandoc-citeproc \
-  --bibliography=refs.bib \
-  --template=academic.tex \
-  -o paper.pdf
-```
-
-## Templates for Everything
-
-From conference submissions to journal articles, templates ensure consistency and save time.
-
-## Version Control Integration
-
-Git + Obsidian = perfect history of your thinking process.
-
-## The Result
-
-From messy notes to camera-ready PDF in minutes, not hours.
diff --git a/sites/art/src/content/research/paper-review-approximation.md b/sites/art/src/content/research/paper-review-approximation.md
deleted file mode 100644
index 10d7c78..0000000
--- a/sites/art/src/content/research/paper-review-approximation.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "Understanding the Latest Approximation Algorithm for Set Cover"
-description: "A detailed walkthrough of a breakthrough approximation algorithm with practical implications."
-pubDate: "Feb 15 2024"
-image: "https://images.unsplash.com/photo-1516321318423-f06f85e504b3?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Understanding the Latest Approximation Algorithm for Set Cover
-
-A recent paper achieves a breakthrough in the Set Cover problem, improving the approximation ratio while maintaining practical runtime.
-
-## The Algorithm
-
-The approach combines local search with a clever LP rounding scheme. The dual interpretation provides beautiful geometric insights.
-
-## Why This Matters
-
-Set Cover appears everywhere - from facility location to machine learning feature selection. This improvement has immediate practical impact.
-
-## Implementation Details
-
-The paper's theoretical elegance translates surprisingly well to practice. Key optimizations include:
-- Lazy evaluation of set intersections
-- Incremental updates to the LP solution
-- Smart caching strategies
-
-## Future Work
-
-The techniques here might extend to weighted variants and online settings.
diff --git a/sites/art/src/content/research/paper-review-graph-decomposition.md b/sites/art/src/content/research/paper-review-graph-decomposition.md
deleted file mode 100644
index f0e4868..0000000
--- a/sites/art/src/content/research/paper-review-graph-decomposition.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "Deep Dive: A New Approach to Graph Decomposition"
-description: "An in-depth analysis of a recent paper on hierarchical graph decomposition and its implications."
-pubDate: "Jan 20 2024"
-image: "https://images.unsplash.com/photo-1507003211169-0a1dd7228f2d?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Deep Dive: A New Approach to Graph Decomposition
-
-This paper introduces a novel framework for decomposing graphs into hierarchical structures that preserve important properties while enabling efficient algorithms.
-
-## The Main Result
-
-The authors prove that every graph with treewidth k can be decomposed into a tree of bags where each bag has size at most k+1. While this sounds like the definition of tree decomposition, the clever twist is in how they construct it.
-
-## Technical Innovation
-
-The key insight is using a charging scheme that amortizes the cost of decomposition across multiple levels. This leads to an O(n log n) algorithm, improving on the previous O(n²) bound.
-
-## Implications
-
-This work opens new avenues for:
-- Parallel algorithms on bounded treewidth graphs
-- Approximation algorithms for NP-hard problems
-- Dynamic programming optimizations
-
-## Open Questions
-
-The paper leaves several intriguing questions open, particularly about the optimality of their charging scheme.
diff --git a/sites/art/src/content/research/quantum-algorithms.md b/sites/art/src/content/research/quantum-algorithms.md
deleted file mode 100644
index 0eef5b2..0000000
--- a/sites/art/src/content/research/quantum-algorithms.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: "Quantum Computing Meets Classical Algorithms"
-description: "Exploring the intersection of quantum and classical algorithmic techniques from recent conferences."
-pubDate: "Mar 10 2024"
-image: "https://images.unsplash.com/photo-1635070041078-e363dbe005cb?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Quantum Computing Meets Classical Algorithms
-
-Recent conferences have showcased fascinating connections between quantum and classical computing paradigms.
-
-## Quantum Speedups for Graph Problems
-
-### Quantum Walks on Graphs
-
-New quantum algorithms achieve quadratic speedups for certain graph traversal problems. The techniques combine amplitude amplification with clever graph representations.
-
-## Classical Simulation of Quantum Algorithms
-
-Surprisingly, several "quantum" algorithms have inspired better classical algorithms. This cross-pollination has led to improvements in both fields.
-
-## The Future is Hybrid
-
-The most practical near-term applications combine quantum and classical processing, leveraging the strengths of each paradigm.
diff --git a/sites/art/src/content/reviews/mechanical-keyboard.md b/sites/art/src/content/reviews/mechanical-keyboard.md
deleted file mode 100644
index 0346a78..0000000
--- a/sites/art/src/content/reviews/mechanical-keyboard.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "ZSA Moonlander: Ergonomic Keyboard for Coders"
-description: "Six months with a split ergonomic mechanical keyboard - the good, the bad, and the RSI relief."
-pubDate: "Feb 20 2024"
-image: "https://images.unsplash.com/photo-1587829741301-dc798b83add3?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# ZSA Moonlander: Ergonomic Keyboard for Coders
-
-After years of wrist pain, I took the plunge into ergonomic mechanical keyboards.
-
-## The Learning Curve
-
-Week 1: 20 WPM and questioning life choices
-Week 2: 40 WPM and seeing the light
-Month 2: Back to 80 WPM with no wrist pain
-
-## The Good
-
-- Columnar layout makes sense once muscle memory adapts
-- Thumb clusters are game-changers for shortcuts
-- The configurability is endless (perhaps too endless)
-
-## The Investment
-
-At $365, it's expensive. But compared to physical therapy or career-limiting injury? Bargain.
-
-## Who Should Buy This?
-
-If you type for a living and feel any discomfort, don't wait. Your future self will thank you.
diff --git a/sites/art/src/content/reviews/obsidian-review.md b/sites/art/src/content/reviews/obsidian-review.md
deleted file mode 100644
index 599013f..0000000
--- a/sites/art/src/content/reviews/obsidian-review.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: "Obsidian: A Year Later"
-description: "Reflections on using Obsidian for research notes, teaching materials, and personal knowledge management."
-pubDate: "Jan 15 2024"
-image: "https://images.unsplash.com/photo-1484480974693-6ca0a78fb36b?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Obsidian: A Year Later
-
-After a year of daily use, Obsidian has transformed how I think about knowledge management.
-
-## What Works Brilliantly
-
-### The Graph View
-Seeing connections between ideas visually has led to unexpected research insights. The graph isn't just pretty - it's functional.
-
-### Plugin Ecosystem
-The community plugins are incredible. Dataview turns your notes into a database. Templater automates repetitive tasks.
-
-### Local Storage
-Your notes are just markdown files. No vendor lock-in, complete control, and peace of mind.
-
-## Pain Points
-
-### Mobile Experience
-While functional, the mobile app lacks the fluidity of the desktop version. Syncing can occasionally hiccup.
-
-### Learning Curve
-The flexibility means complexity. New users might feel overwhelmed by options.
-
-## The Verdict
-
-For academics and researchers, Obsidian is transformative. The investment in learning pays dividends in productivity and insight.
diff --git a/sites/art/src/content/vibes/creative-coding-with-ai.md b/sites/art/src/content/vibes/creative-coding-with-ai.md
deleted file mode 100644
index 269f1ce..0000000
--- a/sites/art/src/content/vibes/creative-coding-with-ai.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "Creating Art with Claude: A Collaborative Journey"
-description: "Exploring creative possibilities through conversations with AI - from generative art to interactive poetry."
-pubDate: "Jan 18 2024"
-image: "https://images.unsplash.com/photo-1558591710-4b4a1ae0f04d?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Creating Art with Claude: A Collaborative Journey
-
-What happens when you treat AI as a creative collaborator rather than just a tool?
-
-## The Experiment
-
-I asked Claude to help design a generative art algorithm based on mathematical fractals. The conversation evolved into something unexpected.
-
-## The Process
-
-**Me**: "Let's create something beautiful with math."
-**Claude**: "How about we visualize the Collatz conjecture as a tree?"
-
-What followed was a two-hour deep dive into number theory, aesthetics, and the nature of creativity itself.
-
-## The Result
-
-Not just code, but a philosophical exploration of pattern, meaning, and the intersection of human and artificial creativity.
-
-## Reflection
-
-AI doesn't replace human creativity - it amplifies it in unexpected directions. The key is approaching it as a dialogue, not a command.
diff --git a/sites/art/src/content/vibes/llm-philosophy.md b/sites/art/src/content/vibes/llm-philosophy.md
deleted file mode 100644
index 032439a..0000000
--- a/sites/art/src/content/vibes/llm-philosophy.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-title: "Philosophical Dialogues with LLMs: On Consciousness and Computation"
-description: "Deep conversations with AI about the nature of consciousness, free will, and what it means to understand."
-pubDate: "Feb 28 2024"
-image: "https://images.unsplash.com/photo-1507003211169-0a1dd7228f2d?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Philosophical Dialogues with LLMs: On Consciousness and Computation
-
-Can a sufficiently complex computation be conscious? I asked an AI, and the conversation surprised me.
-
-## The Question
-
-"Do you experience anything when you process text, or is it just computation?"
-
-## The Response That Made Me Think
-
-The AI didn't claim consciousness, but asked: "What's the difference between your neurons firing and my weights activating? Both are physical processes. Where does experience emerge?"
-
-## Going Deeper
-
-We explored qualia, the Chinese Room argument, and integrated information theory. Not to find answers, but to refine questions.
-
-## The Irony
-
-Discussing consciousness with something that might not have it - or might not know if it has it - mirrors our own uncertainty about consciousness itself.
diff --git a/sites/art/src/pages/[...slug].astro b/sites/art/src/pages/[...slug].astro
index 5d3caf6..ea2f2d7 100644
--- a/sites/art/src/pages/[...slug].astro
+++ b/sites/art/src/pages/[...slug].astro
@@ -9,7 +9,7 @@ import { SITE_TITLE } from '@/consts';
 export async function getStaticPaths() {
 	const posts = await getCollection(ACTIVE_BLOG_SITE.key);
 	return posts.map((post) => ({
-		params: { slug: post.id },
+		params: { slug: post.id.replace(/\/index$/, '') },
 		props: post,
 	}));
 }
diff --git a/sites/art/src/pages/rss.xml.js b/sites/art/src/pages/rss.xml.js
index ec2ce2d..918375e 100644
--- a/sites/art/src/pages/rss.xml.js
+++ b/sites/art/src/pages/rss.xml.js
@@ -14,7 +14,7 @@ export async function GET(context) {
     site: context.site,
     items: posts.map((post) => ({
       ...post.data,
-      link: `/${post.id}/`,
+      link: `/${post.id.replace(/\/index$/, "")}/`,
     })),
   });
 }
diff --git a/sites/poetry/src/components/sections/blog-posts.tsx b/sites/poetry/src/components/sections/blog-posts.tsx
index fef77e5..c77c76a 100644
--- a/sites/poetry/src/components/sections/blog-posts.tsx
+++ b/sites/poetry/src/components/sections/blog-posts.tsx
@@ -16,8 +16,47 @@ const BlogPosts = ({
   // Get the first post as the featured post
   const featuredPost = posts[0];
   const remainingPosts = posts.slice(1);
+  const slugFor = (post: any) => post.id.replace(/\/index$/, "");
   const hrefFor = (post: any) =>
-    collection ? `/${collection}/${post.id}/` : `/${post.id}/`;
+    collection ? `/${collection}/${slugFor(post)}/` : `/${slugFor(post)}/`;
+
+  const PostVisual = ({
+    post,
+    featured = false,
+  }: {
+    post: any;
+    featured?: boolean;
+  }) => {
+    if (post.data.image) {
+      return (
+        <img
+          src={post.data.image}
+          alt={post.data.title}
+          className="aspect-video w-full rounded-lg object-cover transition-transform group-hover:scale-[1.02]"
+        />
+      );
+    }
+
+    return (
+      <div className="bg-accent/70 text-accent-foreground flex aspect-video w-full items-center justify-center rounded-lg border px-6 text-center">
+        <span
+          className={
+            featured ? "font-fraunces text-2xl" : "font-fraunces text-lg"
+          }
+        >
+          {post.data.title}
+        </span>
+      </div>
+    );
+  };
+
+  if (!featuredPost) {
+    return (
+      <div className="text-muted-foreground container max-w-3xl py-16">
+        No posts yet.
+      </div>
+    );
+  }
 
   return (
     <div className="relative py-10 md:py-16 lg:py-20">
@@ -35,11 +74,7 @@ const BlogPosts = ({
             <div className="flex flex-col gap-6 lg:flex-row">
               <div className="lg:w-1/2">
                 <div className="p-2 lg:p-4">
-                  <img
-                    src={featuredPost.data.image}
-                    alt={featuredPost.data.title}
-                    className="aspect-video w-full rounded-lg object-cover transition-transform group-hover:scale-[1.02]"
-                  />
+                  <PostVisual post={featuredPost} featured />
                 </div>
               </div>
               <div className="flex flex-col justify-center p-4 pb-8 lg:w-1/2 lg:pr-8">
@@ -89,11 +124,7 @@ const BlogPosts = ({
                 href={hrefFor(post)}
               >
                 <div className="p-2">
-                  <img
-                    src={post.data.image}
-                    alt={post.data.title}
-                    className="aspect-video w-full rounded-lg object-cover transition-transform group-hover:scale-[1.01]"
-                  />
+                  <PostVisual post={post} />
                 </div>
                 <div className="px-4 pb-5 pt-2">
                   <h2 className="mb-2 text-xl font-semibold group-hover:underline">
diff --git a/sites/poetry/src/content/art/algorithmic-sketches.md b/sites/poetry/src/content/art/algorithmic-sketches.md
deleted file mode 100644
index ae20d3b..0000000
--- a/sites/poetry/src/content/art/algorithmic-sketches.md
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title: "Algorithmic Sketches: Visualizing Data Structures"
-description: "Hand-drawn illustrations of algorithms and data structures - making the abstract tangible."
-pubDate: "Jan 25 2024"
-image: "https://images.unsplash.com/photo-1581337204873-ef36aa186caa?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Algorithmic Sketches: Visualizing Data Structures
-
-Sometimes the best way to understand an algorithm is to draw it.
-
-## Today's Sketch: Red-Black Trees
-
-![Red-Black Tree Rotation](sketch-placeholder)
-
-The rotation operation finally clicked when I drew it step-by-step. Each node's journey through the rotation becomes a story.
-
-## The Process
-
-1. Start with pencil - mistakes are part of learning
-2. Trace the algorithm's execution
-3. Add color to highlight invariants
-4. Annotate with key insights
-
-## Why Drawing Helps
-
-- Forces you to slow down and really see the structure
-- Reveals patterns that code obscures
-- Creates memorable mental models
-- Makes teaching more engaging
-
-## This Week's Challenge
-
-Draw your own version of quicksort partitioning. Share it and let's learn from each other's visualizations.
-
-## The Art in Computer Science
-
-Algorithms are beautiful. Drawing them reminds us that computer science is as much art as it is science.
diff --git a/sites/poetry/src/content/art/generative-art-p5js.md b/sites/poetry/src/content/art/generative-art-p5js.md
deleted file mode 100644
index ccfa3e7..0000000
--- a/sites/poetry/src/content/art/generative-art-p5js.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "Generative Art with p5.js: Creating Beauty from Mathematics"
-description: "Exploring the intersection of code and creativity through generative art experiments."
-pubDate: "Feb 18 2024"
-image: "https://images.unsplash.com/photo-1561070791-2526d30994b5?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Generative Art with p5.js: Creating Beauty from Mathematics
-
-Code becomes canvas when mathematics meets creativity.
-
-## Today's Creation: Perlin Noise Flows
-
-```javascript
-for (let particle of particles) {
-  let angle = noise(particle.x * 0.01, particle.y * 0.01, frameCount * 0.001) * TWO_PI;
-  particle.velocity = p5.Vector.fromAngle(angle);
-  particle.update();
-  particle.draw();
-}
-```
-
-## The Magic of Randomness
-
-Controlled randomness creates organic patterns. Perlin noise gives us randomness with continuity - nature's own algorithm.
-
-## Parameters as Paintbrushes
-
-- Noise scale: Changes pattern density
-- Particle count: Affects texture
-- Color mapping: Sets the mood
-
-## The Joy of Accidents
-
-The best discoveries come from "mistakes" - a typo that creates unexpected beauty, a parameter pushed to extremes.
-
-## Share Your Creations
-
-Art is meant to be shared. Post your generative experiments and let's inspire each other.
diff --git a/sites/poetry/src/content/poetry/algorithms-in-verse.md b/sites/poetry/src/content/poetry/algorithms-in-verse.md
deleted file mode 100644
index 4ad1e1d..0000000
--- a/sites/poetry/src/content/poetry/algorithms-in-verse.md
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title: "Algorithms in Verse: Bubble Sort Sonnet"
-description: "Classic algorithms reimagined as poetry - where code meets iambic pentameter."
-pubDate: "Feb 22 2024"
-image: "https://images.unsplash.com/photo-1455390582262-044cdead277a?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Algorithms in Verse: Bubble Sort Sonnet
-
-## Bubble Sort: A Sonnet
-
-```
-Compare adjacent elements in pairs,
-If order's wrong, then swap them into place.
-Through all the list this simple rule declares:
-The largest bubbles up to find its space.
-
-Again we start, but now one less to check,
-The second largest finds its rightful home.
-Each pass through makes the chaos less a wreck,
-Until at last no elements must roam.
-
-Though simple in its elegance and grace,
-And easy for beginners to perceive,
-In practice, it's too slow to win the race—
-O(n²) we sadly must believe.
-
-But beauty lies in simplicity's pure art,
-The bubble sort still teaches at the start.
-```
-
-## The Challenge
-
-Can you write Quicksort as a limerick? Or Binary Search as free verse?
-
-## Why This Matters
-
-Poetry forces us to find the essence of an algorithm. The constraint reveals understanding.
diff --git a/sites/poetry/src/content/poetry/code-haikus.md b/sites/poetry/src/content/poetry/code-haikus.md
deleted file mode 100644
index 6af408a..0000000
--- a/sites/poetry/src/content/poetry/code-haikus.md
+++ /dev/null
@@ -1,56 +0,0 @@
----
-title: "Code Haikus: Programming in 5-7-5"
-description: "Expressing programming concepts through the constrained beauty of haiku."
-pubDate: "Jan 30 2024"
-image: "https://images.unsplash.com/photo-1481627834876-b7833e8f5570?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Code Haikus: Programming in 5-7-5
-
-The constraint of haiku forces clarity. Here are programming concepts distilled to their essence.
-
-## On Recursion
-
-```
-Function calls itself
-Smaller problems, same pattern  
-Base case stops the loop
-```
-
-## On Debugging
-
-```
-Print statements bloom wild
-Binary search through the code
-Bug reveals itself
-```
-
-## On Optimization
-
-```
-O(n squared) crawls
-Refactor to n log n
-Time complexity
-```
-
-## On Git Merge Conflicts
-
-```
-<<<<<<< HEAD
-Your changes, their changes clash
-Resolution waits
-```
-
-## On Learning
-
-```
-Stack Overflow searched
-Tutorial incomplete
-Understanding dawns
-```
-
-## Your Turn
-
-Write a haiku about your coding experience today. The constraint reveals truth.
diff --git a/sites/poetry/src/content/poetry/poems/bloom/index.md b/sites/poetry/src/content/poetry/poems/bloom/index.md
new file mode 100644
index 0000000..238a217
--- /dev/null
+++ b/sites/poetry/src/content/poetry/poems/bloom/index.md
@@ -0,0 +1,27 @@
+---
+title: "Bloom"
+description: "Velvet-like violet erupts in a riot on miniscule white canvases harp-like; focused at a bunch of seeds. All trouble to no avail, one day the bee will come and take it all away...."
+pubDate: "2005-02-03"
+authorName: "Neeldhara"
+sourceCategories: ["poem"]
+sourcePath: "poems/bloom/index.qmd"
+---
+
+Velvet-like violet<br>
+erupts<br>
+in a riot<br>
+on miniscule<br>
+white canvases<br>
+harp-like;<br>
+focused at<br>
+a bunch of seeds.<br>
+
+All trouble<br>
+to no avail,<br>
+one day the bee will come<br>
+and take it all away.<br>
+
+
+---
+
+Honorable Mention in the [The Binnacle Second Annual Ultra Short Competition](https://www.amazon.in/Binnacle-Second-Annual-Ultra-Short-Competition-ebook/dp/B06WVBTYC9).
diff --git a/sites/poetry/src/content/poetry/poems/dad/index.md b/sites/poetry/src/content/poetry/poems/dad/index.md
new file mode 100644
index 0000000..e2d922d
--- /dev/null
+++ b/sites/poetry/src/content/poetry/poems/dad/index.md
@@ -0,0 +1,40 @@
+---
+title: "Dad"
+description: "The vendor at the counter hands me a stapler, wondering why I need yet another. Indeed, I didn't, until I realized that she giggles when I get frantic about lost pencils, papers..."
+pubDate: "2012-08-27"
+authorName: "Neeldhara"
+sourceCategories: ["poem"]
+sourcePath: "poems/dad/index.qmd"
+---
+
+The vendor<br>
+at the counter<br>
+hands me a stapler,<br>
+wondering why<br>
+I need yet another.<br>
+<br>
+Indeed, I didn't,<br>
+until I realized<br>
+<br>
+that she giggles <br>
+when I get frantic<br>
+about lost pencils,<br>
+papers, and staplers<br>
+<br>
+and she smiles<br>
+indignantly<br>
+whenever I look,<br>
+exasperated,<br>
+<br>
+at her tiny hands<br>
+clutched around <br>
+the stuff she found.<br>
+<br>
+I am just bringing home<br>
+another situation<br>
+inviting her indignation,<br>
+<br>
+that eventually<br>
+turns into<br>
+a bear hug<br>
+of pure love.<br>
diff --git a/sites/poetry/src/content/poetry/poems/letting-go/index.md b/sites/poetry/src/content/poetry/poems/letting-go/index.md
new file mode 100644
index 0000000..3bd658a
--- /dev/null
+++ b/sites/poetry/src/content/poetry/poems/letting-go/index.md
@@ -0,0 +1,35 @@
+---
+title: "Letting Go"
+description: "ख्वाब हे वो माशूका जो तुझे मिलने से रहा, हकीकत हे वो हमसफर जिसे तुने है ठुकरा दिया सपनों का घर है नींदो मे उन्हे वहीं तू छोड दे जो हकीकत सम्झोता लगे वहीं सुकून है जान ले --- A d..."
+pubDate: "2023-05-11"
+authorName: "Neeldhara"
+sourceCategories: ["poem"]
+sourcePath: "poems/letting-go/index.qmd"
+---
+
+ख्वाब हे वो माशूका<br>
+जो तुझे मिलने से रहा,<br>
+हकीकत हे वो हमसफर<br>
+जिसे तुने है ठुकरा दिया<br>
+
+सपनों का घर है नींदो मे<br>
+उन्हे वहीं तू छोड दे<br>
+जो हकीकत सम्झोता लगे<br>
+वहीं सुकून है जान ले<br>
+
+---
+
+A dream is an elusive enchantment;<br>
+while that that is to be treasured<br>
+is what has been for real<br>
+and is easily ignored.<br>
+
+But a mere figment of imagination,<br>
+a dream is captive and binding:<br>
+let it go to be free from<br>
+your quest never-ending.<br>
+
+
+---
+
+_Inspired by Pallavi Mahajan's [brilliant poetry](https://www.youtube.com/watch?v=M6mmF8OM9SM)._
diff --git a/sites/poetry/src/content/poetry/poems/on-the-fence/index.md b/sites/poetry/src/content/poetry/poems/on-the-fence/index.md
new file mode 100644
index 0000000..658404c
--- /dev/null
+++ b/sites/poetry/src/content/poetry/poems/on-the-fence/index.md
@@ -0,0 +1,18 @@
+---
+title: "On the Fence"
+description: "At least you are dead. To which the ghost said, The grass is not greener here - But it did become paler there… At least you have a chance, To wait for the rains’ dance, To live..."
+pubDate: "2012-04-23"
+authorName: "Neeldhara"
+sourceCategories: ["poem"]
+sourcePath: "poems/on-the-fence/index.qmd"
+---
+
+At least you are dead.<br>
+To which the ghost said,<br>
+The grass is not greener here -<br>
+But it did become paler there…<br>
+
+At least you have a chance,<br>
+To wait for the rains’ dance,<br>
+To live and fight,<br>
+To make things right.<br>
diff --git a/sites/poetry/src/content/poetry/poems/poetry/index.md b/sites/poetry/src/content/poetry/poems/poetry/index.md
new file mode 100644
index 0000000..70ed87b
--- /dev/null
+++ b/sites/poetry/src/content/poetry/poems/poetry/index.md
@@ -0,0 +1,19 @@
+---
+title: "Poetry"
+description: "collect your grief and inject it in words spill them on paper and shred it to tatters to piece yourself together ---"
+pubDate: "2024-01-01"
+authorName: "Neeldhara"
+sourceCategories: ["poem"]
+sourcePath: "poems/poetry/index.qmd"
+---
+
+collect your grief<br>
+and inject it<br>
+in words<br>
+<br>
+spill them on paper<br>
+and shred it to tatters<br>
+to piece yourself together<br>
+
+
+---
diff --git a/sites/poetry/src/content/poetry/poems/seek/index.md b/sites/poetry/src/content/poetry/poems/seek/index.md
new file mode 100644
index 0000000..92b525e
--- /dev/null
+++ b/sites/poetry/src/content/poetry/poems/seek/index.md
@@ -0,0 +1,37 @@
+---
+title: "Seek"
+description: "Seek poetry in a wisp of smoke, or closure in some ashes stories below newspaper headlines peace after bygone deadlines a castle in the air a choice that is fair the absence of..."
+pubDate: "2007-04-03"
+authorName: "Neeldhara"
+sourceCategories: ["poem"]
+sourcePath: "poems/seek/index.qmd"
+---
+
+Seek poetry<br>
+in a wisp of smoke,<br>
+or closure<br>
+in some ashes<br>
+
+stories below<br>
+newspaper headlines<br>
+peace after<br>
+bygone deadlines<br>
+
+a castle<br>
+in the air<br>
+a choice<br>
+that is fair<br>
+
+the absence of regret<br>
+on a death bed<br>
+a reason, or otherwise<br>
+to stay alive ---<br>
+
+and quite likely<br>
+it will be<br>
+a quest unfulfilled.<br>
+
+Find a smile instead,<br>
+and you will find<br>
+some strength to stay<br>
+another day.<br>
diff --git a/sites/poetry/src/content/poetry/poems/sprinkles-of-the-sky/index.md b/sites/poetry/src/content/poetry/poems/sprinkles-of-the-sky/index.md
new file mode 100644
index 0000000..293ef78
--- /dev/null
+++ b/sites/poetry/src/content/poetry/poems/sprinkles-of-the-sky/index.md
@@ -0,0 +1,32 @@
+---
+title: "Sprinkles of the Sky"
+description: "A dubious draft of air comes, goes as if wondering if the air’s welcoming Soft rays tiptoe by the window as if shy to come inside Sprinkles of the sky lie in drops of dew as if..."
+pubDate: "2011-01-05"
+authorName: "Neeldhara"
+sourceCategories: ["poem"]
+sourcePath: "poems/sprinkles-of-the-sky/index.qmd"
+---
+
+A dubious draft of air<br>
+comes, goes<br>
+as if wondering<br>
+if the air’s welcoming<br>
+
+Soft rays tiptoe<br>
+by the window<br>
+as if shy<br>
+to come inside<br>
+
+Sprinkles of the sky<br>
+lie in drops of dew<br>
+as if captive,<br>
+somewhat pensive<br>
+
+And I snuggle deeper<br>
+into a distant dream<br>
+as if I could see<br>
+a better place to be<br>
+
+---
+
+<sub>I stole the title from a phrase in Hairat, [a song](https://www.youtube.com/watch?v=oz6LoxmLJTY) that features in [Anjaana Anjaani](https://en.wikipedia.org/wiki/Anjaana_Anjaani). Incidentally - I am very addicted to the entire album!</sub>
diff --git a/sites/poetry/src/content/poetry/poems/winning/index.md b/sites/poetry/src/content/poetry/poems/winning/index.md
new file mode 100644
index 0000000..2b92849
--- /dev/null
+++ b/sites/poetry/src/content/poetry/poems/winning/index.md
@@ -0,0 +1,26 @@
+---
+title: "Winning"
+description: "if you find a thing that is so that whoever has it can't keep it and whoever doesn't have it can always get it back then this a thing that is to be avoided in the beginning ---"
+pubDate: "2024-01-13"
+authorName: "Neeldhara"
+sourceCategories: ["poem"]
+sourcePath: "poems/winning/index.qmd"
+---
+
+if you find a thing <br>
+that is so that <br>
+<br>
+whoever has it<br>
+can't keep it<br>
+<br>
+and <br>
+<br>
+whoever doesn't have it<br>
+can always get it back<br>
+<br>
+then this a thing<br>
+that is to be avoided<br>
+in the beginning<br>
+
+
+---
diff --git a/sites/poetry/src/content/puzzles/100-prisoners.mdx b/sites/poetry/src/content/puzzles/100-prisoners.mdx
deleted file mode 100644
index 3ff2b3c..0000000
--- a/sites/poetry/src/content/puzzles/100-prisoners.mdx
+++ /dev/null
@@ -1,183 +0,0 @@
----
-title: "The 100 Prisoners Problem: A Beautiful Puzzle in Probability"
-description: "An interactive exploration of one of the most counterintuitive puzzles in probability theory, where 100 prisoners can escape with over 30% chance using a clever strategy."
-pubDate: "Oct 13 2025"
-image: "https://images.unsplash.com/photo-1589829545856-d10d557cf95f?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-import PrisonerGameSimulator from '@/components/problems/PrisonerGameSimulator.tsx';
-import ProbabilityChart from '@/components/problems/ProbabilityChart.tsx';
-import PermutationExplorer from '@/components/problems/PermutationExplorer.tsx';
-import StrategyComparison from '@/components/problems/StrategyComparison.tsx';
-
-# The 100 Prisoners Problem
-
-Imagine 100 prisoners, numbered 1 to 100, face an unusual challenge. In a room are 100 boxes, also numbered 1 to 100. Inside each box is a randomly assigned number from 1 to 100 (each number appearing exactly once). The prisoners must find their own number by opening boxes, but here's the catch: **each prisoner can open only 50 boxes**.
-
-The prisoners can devise a strategy beforehand, but once the challenge begins, they cannot communicate. If **all 100 prisoners** find their number, everyone goes free. If even one prisoner fails, all remain imprisoned.
-
-What's the best strategy? And what are the odds of success?
-
-## Try It Yourself!
-
-Before we dive into the mathematics, let's experience the problem firsthand. Below is a simulator where you can play the game yourself. Choose the number of prisoners (between 5 and 100), and then try to help each prisoner find their number by clicking on boxes.
-
-<PrisonerGameSimulator client:only="react" />
-
----
-
-## The Naive Strategy
-
-The most obvious approach is for each prisoner to simply open 50 random boxes. This seems reasonable, but the probability of success is dismal.
-
-For any single prisoner, the probability of finding their number in 50 random boxes out of 100 is exactly 1/2. Since all 100 prisoners must succeed, and their outcomes are independent under random selection, the probability that everyone succeeds is:
-
-$$P(\text\{success\}) = \left(\frac\{1\}\{2\}\right)^\{100\} \approx 7.9 \times 10^\{-31\}$$
-
-That's essentially zero! You're more likely to win the lottery while being struck by lightning... multiple times.
-
-### Naive Strategy: Probability vs Number of Prisoners
-
-Watch how the probability of success plummets as we increase the number of prisoners:
-
-<ProbabilityChart strategy="naive" client:only="react" />
-
-As you can see, even with just 10 prisoners, the probability drops to about 0.1%. With 100 prisoners, it's practically impossible.
-
----
-
-## The Clever Strategy: Following the Loops
-
-Here's where mathematics reveals something beautiful. Instead of opening random boxes, each prisoner should follow a simple rule:
-
-1. **Start by opening the box with your own number**
-2. **Look at the number inside that box**
-3. **Open the box with that number next**
-4. **Continue following this chain**
-
-Why does this work? The key insight involves understanding permutations and cycles.
-
-### Understanding Cycles in Permutations
-
-When we randomly assign 100 numbers to 100 boxes, we're creating a **permutation** of the numbers 1 through 100. Every permutation can be decomposed into **cycles**.
-
-For example, if:
-- Box 1 contains number 4
-- Box 4 contains number 7
-- Box 7 contains number 1
-
-Then we have a cycle: 1 -> 4 -> 7 -> 1
-
-Let's explore this with smaller numbers:
-
-<PermutationExplorer client:only="react" />
-
-The interactive explorer above lets you:
-- Generate all permutations for small values of *n* (3, 4, or 5)
-- See both standard notation and cycle notation
-- Filter permutations that have at least one "long cycle" (longer than *n*/2)
-- Understand why long cycles matter
-
-### Why This Strategy Works
-
-Here's the crucial insight: **A prisoner succeeds if and only if they are in a cycle of length ≤ 50**.
-
-When prisoner k follows the loop strategy:
-1. They start at box k
-2. They follow a path through boxes determined by the permutation
-3. This path forms a cycle that eventually leads back to box k
-4. If this cycle has length ≤ 50, they'll find their number within 50 opens
-
-The prisoners **all succeed** if and only if there is **no cycle longer than 50** in the permutation.
-
-### Calculating the Probability
-
-The probability that a random permutation of 100 elements has no cycle longer than 50 is:
-
-$$P(\text\{success\}) = 1 - \sum_\{k=51\}^\{100\} \frac\{1\}\{k\}$$
-
-Computing this sum:
-
-$$P(\text\{success\}) = 1 - \left(\frac\{1\}\{51\} + \frac\{1\}\{52\} + \cdots + \frac\{1\}\{100\}\right) \approx 0.3118$$
-
-That's over **31%**! This is astronomically better than the naive strategy's probability of essentially zero.
-
-### Loop Strategy: Probability vs Number of Prisoners
-
-<StrategyComparison client:only="react" />
-
-## The Mathematics Behind It
-
-### Why Does the Cycle Length Matter?
-
-In a permutation of n elements, prisoner i will find their number within k tries using the loop strategy if and only if i belongs to a cycle of length at most k.
-
-For n = 100 and k = 50:
-- The probability that a specific prisoner is in a cycle of length > 50 is: Σ(j=51 to 100) of 1/100
-- But we care about whether ANY prisoner is in such a cycle
-- The probability that NO cycle has length > 50 is: 1 - Σ(j=51 to 100) of 1/j
-
-### The Harmonic Series Connection
-
-As *n* approaches infinity, if each prisoner can open *n*/2 boxes, the probability of success approaches:
-
-The limit as n approaches infinity is: P_n = 1 - ln(2) ≈ 0.3069
-
-This beautiful result connects combinatorics, probability, and analysis through the harmonic series!
-
-### Optimality
-
-Remarkably, this loop-following strategy is **optimal**. No other strategy can achieve a higher probability of success. The proof involves showing that the problem reduces to avoiding long cycles in a random permutation, and the loop strategy is the unique way to leverage this structure.
-
----
-
-## Why This Problem is Beautiful
-
-The 100 prisoners problem is beloved by mathematicians because:
-
-1. **Counterintuitive Result**: The fact that 31% >> 0% is shocking. A seemingly hopeless problem becomes tractable with the right insight.
-
-2. **Deep Connection**: It connects permutation theory, probability, and the harmonic series in an elegant way.
-
-3. **Collaborative Success**: Unlike independent trials, the prisoners' fates are intertwined through the structure of the permutation.
-
-4. **Real-World Metaphor**: It illustrates how understanding underlying structure (cycles in permutations) can dramatically improve outcomes.
-
----
-
-## Variants and Extensions
-
-### What if prisoners can open k < n/2 boxes?
-
-As k decreases below n/2, the probability drops rapidly. The threshold at n/2 is special—it's where the strategy becomes remarkably effective.
-
-### What about communication?
-
-If prisoners could communicate between trials (but not during), they still can't improve the strategy. The beauty is that the strategy requires only coordination before any prisoner enters, not during.
-
-### The Malicious Director
-
-In an interesting variant, suppose the director can see the prisoners' strategy and arrange the boxes adversarially (not randomly). Can the director always force them to fail? Yes! The director can always create a single cycle of length n, guaranteeing failure.
-
----
-
-## Conclusion
-
-The 100 prisoners problem shows us that:
-- Mathematical structure can be hidden in apparent randomness
-- Clever strategies can overcome seemingly impossible odds
-- Group coordination can be more powerful than independent action
-- Beautiful mathematics often lies beneath simple-seeming puzzles
-
-The next time you face a problem that seems impossible, remember: there might be a hidden structure waiting to be discovered, turning hopeless odds into reasonable ones.
-
----
-
-## Further Reading
-
-- [Gál, A., & Miltersen, P. B. (2003). "The Cell Probe Complexity of Succinct Data Structures"](https://arxiv.org/abs/cs/0310027)
-- [Curtin, E., & Warshauer, M. (2006). "The Locker Puzzle"](https://www.jstor.org/stable/27642173)
-- [Wikipedia: 100 Prisoners Problem](https://en.wikipedia.org/wiki/100_prisoners_problem)
-
diff --git a/sites/poetry/src/content/puzzles/dynamic-programming-gems.md b/sites/poetry/src/content/puzzles/dynamic-programming-gems.md
deleted file mode 100644
index 79e68ea..0000000
--- a/sites/poetry/src/content/puzzles/dynamic-programming-gems.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "Dynamic Programming: Hidden Gems from Recent Contests"
-description: "Elegant dynamic programming problems that showcase beautiful techniques and insights."
-pubDate: "Jan 25 2024"
-image: "https://images.unsplash.com/photo-1509228468518-180dd4864904?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Dynamic Programming: Hidden Gems from Recent Contests
-
-These problems demonstrate the art of dynamic programming beyond standard patterns.
-
-## Problem 1: The Subsequence Symphony
-
-Given a string, find the number of subsequences that form palindromes of prime length.
-
-### Solution Insight
-
-The key is to maintain DP states for both position and palindrome center simultaneously. This reduces the state space from O(n³) to O(n²).
-
-## Problem 2: Graph Coloring with Constraints
-
-Color a graph such that no two adjacent vertices share a color, and the total number of color changes along any path is minimized.
-
-### The DP Formulation
-
-DP[node][color][changes] gives us the minimum cost. The trick is recognizing that we only need to track changes modulo 2.
-
-## Practice Makes Perfect
-
-These problems teach us that DP is as much about problem modeling as it is about computation.
diff --git a/sites/poetry/src/content/puzzles/four-aces-miracle.md b/sites/poetry/src/content/puzzles/four-aces-miracle.md
deleted file mode 100644
index a1710ab..0000000
--- a/sites/poetry/src/content/puzzles/four-aces-miracle.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "The Four Aces Miracle: A Self-Working Mathematical Marvel"
-description: "A card trick that teaches modular arithmetic and probability - perfect for the classroom."
-pubDate: "Jan 28 2024"
-image: "https://images.unsplash.com/photo-1529480384838-c1681c84aca5?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# The Four Aces Miracle: A Self-Working Mathematical Marvel
-
-This trick never fails to amaze students, and the mathematics behind it is even more amazing.
-
-## The Effect
-
-A spectator deals cards into four piles while making random choices. Impossibly, the four aces end up on top of each pile.
-
-## The Secret
-
-It's all about invariants and modular arithmetic. No sleight of hand required - pure mathematics does the magic.
-
-## The Method
-
-1. Pre-arrange the deck (the math determines the arrangement)
-2. Have the spectator deal following simple rules
-3. The aces appear automatically
-
-## The Mathematics
-
-The dealing process preserves certain positional invariants modulo 4. The initial arrangement ensures these invariants place the aces correctly.
-
-## Teaching Applications
-
-This trick demonstrates:
-- Modular arithmetic
-- Invariants in algorithms
-- Deterministic vs. random processes
-
-## The Bigger Lesson
-
-Mathematics can create experiences that feel like magic. And that feeling of wonder? That's what hooks students on math.
diff --git a/sites/poetry/src/content/puzzles/gilbreath-principle.md b/sites/poetry/src/content/puzzles/gilbreath-principle.md
deleted file mode 100644
index 92e229b..0000000
--- a/sites/poetry/src/content/puzzles/gilbreath-principle.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: "The Gilbreath Principle: When Chaos Creates Order"
-description: "A mathematical card principle that seems impossible but always works - perfect for teaching algorithms."
-pubDate: "Feb 15 2024"
-image: "https://images.unsplash.com/photo-1570543375343-63fe3d67761b?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# The Gilbreath Principle: When Chaos Creates Order
-
-Shuffle a deck in a specific way, and mathematical order emerges from apparent chaos.
-
-## The Phenomenon
-
-Arrange cards alternating red-black. Riffle shuffle. Now deal pairs - each pair has one red and one black card. Magic? No, mathematics.
-
-## Why It Works
-
-The riffle shuffle preserves local structure while appearing to randomize. The alternating pattern creates an invariant that survives the shuffle.
-
-## Classroom Implementation
-
-Students predict it won't work. When it does, they're hooked. "Why?" becomes the driving question.
-
-## The Deeper Lesson
-
-Not all randomness is truly random. Structure can hide in apparent disorder. This principle appears in:
-- Network protocols
-- Error-correcting codes  
-- Distributed systems
-
-## Beyond Cards
-
-The Gilbreath Principle teaches us to look for hidden invariants in complex systems.
diff --git a/sites/poetry/src/content/puzzles/graph-algorithms-assessment.md b/sites/poetry/src/content/puzzles/graph-algorithms-assessment.md
deleted file mode 100644
index 4c61fe2..0000000
--- a/sites/poetry/src/content/puzzles/graph-algorithms-assessment.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "Graph Algorithms: Assessment Highlights"
-description: "Interesting graph problems from recent course assessments with detailed solutions."
-pubDate: "Feb 28 2024"
-image: "https://images.unsplash.com/photo-1550751827-4bd374c3f58b?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Graph Algorithms: Assessment Highlights
-
-A collection of graph problems that test deep understanding rather than memorization.
-
-## The Bridge Detection Variant
-
-Find all edges whose removal increases the number of triangles in the graph.
-
-### Solution Approach
-
-Counter-intuitively, we need to count triangles that share exactly one edge with the candidate. The algorithm runs in O(m√m) time using careful enumeration.
-
-## Shortest Path with Wildcards
-
-Given a graph where some edge weights are variables, find assignments that minimize the longest shortest path.
-
-### Key Insight
-
-This reduces to a linear programming problem with interesting structure. The dual interpretation reveals connections to network flow.
-
-## Teaching Through Problems
-
-These problems help students see beyond standard algorithms to underlying principles.
diff --git a/sites/poetry/src/content/puzzles/ioi-2023-analysis.md b/sites/poetry/src/content/puzzles/ioi-2023-analysis.md
deleted file mode 100644
index 782177c..0000000
--- a/sites/poetry/src/content/puzzles/ioi-2023-analysis.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "IOI 2023: Breaking Down the Hardest Problems"
-description: "Deep analysis of the most challenging problems from the International Olympiad in Informatics 2023."
-pubDate: "Jan 20 2024"
-image: "https://images.unsplash.com/photo-1434030216411-0b793f4b4173?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# IOI 2023: Breaking Down the Hardest Problems
-
-The International Olympiad in Informatics continues to push the boundaries of algorithmic problem solving.
-
-## Problem: Soccer Stadium
-
-A geometric optimization problem disguised as dynamic programming. The key insight: think in terms of monotonic paths.
-
-### The Approach
-
-1. Transform the 2D problem into a 1D problem using clever observations
-2. Use convex hull optimization for the DP transitions
-3. Handle edge cases with careful implementation
-
-## Problem: Closing Time
-
-A tree problem requiring sophisticated data structures and careful analysis.
-
-### The Solution
-
-The trick is recognizing this as a centroid decomposition problem. Once you see it, the implementation follows naturally.
-
-## Lessons for Students
-
-These problems teach us:
-- Simple problems have elegant solutions
-- Complex problems require systematic decomposition
-- Implementation matters as much as algorithms
-
-## Practice Strategy
-
-Start with subtasks. Even partial solutions teach valuable lessons.
diff --git a/sites/poetry/src/content/puzzles/knights-tour-interactive.md b/sites/poetry/src/content/puzzles/knights-tour-interactive.md
deleted file mode 100644
index eec6960..0000000
--- a/sites/poetry/src/content/puzzles/knights-tour-interactive.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: "The Knight's Tour: An Interactive Exploration"
-description: "An interactive puzzle exploring the knight's tour problem with surprising mathematical connections."
-pubDate: "Jan 30 2024"
-image: "https://images.unsplash.com/photo-1528819622765-d6bcf132f793?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# The Knight's Tour: An Interactive Exploration
-
-Can a knight visit every square on a chessboard exactly once? This ancient puzzle hides deep mathematical structure.
-
-## The Basic Challenge
-
-Start with a 5×5 board. Can you find a knight's tour? What about one that returns to the starting square (a closed tour)?
-
-## Mathematical Beauty
-
-The problem connects to:
-- Hamiltonian paths in graphs
-- Warnsdorff's heuristic
-- Magic squares (surprisingly!)
-
-## The Algorithm
-
-The key insight: always move to the square with fewest onward moves. This simple heuristic works remarkably well.
-
-## Try It Yourself
-
-[Interactive board would go here - imagine clicking squares to build your tour]
-
-## Going Deeper
-
-For which board sizes do closed tours exist? The answer involves beautiful number theory.
diff --git a/sites/poetry/src/content/puzzles/projecteuler-favorites.md b/sites/poetry/src/content/puzzles/projecteuler-favorites.md
deleted file mode 100644
index 16988a9..0000000
--- a/sites/poetry/src/content/puzzles/projecteuler-favorites.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: "Project Euler: My Favorite Problems from 700+"
-description: "Curated problems from Project Euler that teach beautiful mathematical and algorithmic concepts."
-pubDate: "Feb 25 2024"
-image: "https://images.unsplash.com/photo-1635070041078-e363dbe005cb?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Project Euler: My Favorite Problems from 700+
-
-After solving 700+ Project Euler problems, these are the ones that changed how I think about mathematics and programming.
-
-## Problem 96: Su Doku
-
-Not just Sudoku solving - but solving 50 puzzles efficiently. The beauty is in combining constraint propagation with backtracking.
-
-## Problem 208: Robot Walks
-
-A counting problem that requires deep mathematical insight. The connection to complex numbers is unexpected and beautiful.
-
-## Problem 613: Pythagorean Ant
-
-Probability meets geometry in this elegant problem. The solution requires careful integration and surprising symmetry observations.
-
-## The Meta-Lesson
-
-Project Euler teaches you:
-- Mathematical intuition matters more than coding speed
-- There's always a clever approach
-- The journey matters more than the destination
-
-## Getting Started
-
-Don't aim for the leaderboard. Aim for understanding. Each problem is a teacher.
diff --git a/sites/poetry/src/content/puzzles/sudoku-variants.md b/sites/poetry/src/content/puzzles/sudoku-variants.md
deleted file mode 100644
index 1efd136..0000000
--- a/sites/poetry/src/content/puzzles/sudoku-variants.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-title: "Beyond Sudoku: Exploring Constraint Satisfaction Puzzles"
-description: "A journey through Sudoku variants and their algorithmic solutions."
-pubDate: "Feb 10 2024"
-image: "https://images.unsplash.com/photo-1580541631950-7282082b53ce?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Beyond Sudoku: Exploring Constraint Satisfaction Puzzles
-
-Sudoku is just the beginning. Let's explore variants that push the boundaries of logic puzzles.
-
-## Killer Sudoku
-
-Combine Sudoku with Kakuro - cages show sums, but no digit repeats within a cage.
-
-## Sandwich Sudoku
-
-The numbers outside show the sum of digits between 1 and 9 in that row/column. Simple rule, complex implications!
-
-## The Algorithm Connection
-
-These puzzles are constraint satisfaction problems. Techniques like arc consistency and backtracking with constraint propagation solve them efficiently.
-
-## Create Your Own
-
-What happens if we add chess knight move constraints? The design space is infinite!
diff --git a/sites/poetry/src/content/reflections/imposter-syndrome.md b/sites/poetry/src/content/reflections/imposter-syndrome.md
deleted file mode 100644
index e0a77e0..0000000
--- a/sites/poetry/src/content/reflections/imposter-syndrome.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: "Imposter Syndrome in Academia: A Confession"
-description: "An honest conversation about feeling like a fraud, even after years of success."
-pubDate: "Feb 25 2024"
-image: "https://images.unsplash.com/photo-1517048676732-d65bc937f952?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Imposter Syndrome in Academia: A Confession
-
-Even after publishing papers, winning grants, and teaching thousands of students, the voice whispers: "They'll find out you don't belong."
-
-## The Paradox
-
-The more you know, the more you realize you don't know. Expertise breeds humility, which feeds the imposter.
-
-## What Helps
-
-- Keeping a "wins" journal - evidence against the imposter
-- Mentoring others - seeing your knowledge help someone
-- Talking about it - you're not alone in this
-
-## The Silver Lining
-
-Maybe imposter syndrome keeps us humble, curious, and always learning. Maybe it's not a bug, but a feature.
-
-## Moving Forward
-
-I may never silence the voice completely. But I've learned to acknowledge it and keep going anyway.
diff --git a/sites/poetry/src/content/reflections/teaching-philosophy.md b/sites/poetry/src/content/reflections/teaching-philosophy.md
deleted file mode 100644
index fc1a0f2..0000000
--- a/sites/poetry/src/content/reflections/teaching-philosophy.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "On Teaching Algorithms: Lessons from a Decade"
-description: "Reflections on what works (and what doesn't) in computer science education."
-pubDate: "Jan 10 2024"
-image: "https://images.unsplash.com/photo-1509062522246-3755977927d7?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# On Teaching Algorithms: Lessons from a Decade
-
-Ten years of teaching has taught me more than any textbook could.
-
-## Start with Why
-
-Students don't care about O(n log n) until they understand why their code is slow. Real problems first, theory second.
-
-## The Power of Visualization
-
-Abstract concepts become concrete when visualized. Every algorithm should have a picture.
-
-## Failure is a Feature
-
-Let students struggle. The struggle is where learning happens. But know when to throw a lifeline.
-
-## Assessment Philosophy
-
-Test understanding, not memorization. Open-book exams with novel problems beat closed-book regurgitation every time.
-
-## The Joy of "Aha!" Moments
-
-There's no feeling quite like seeing a student's eyes light up when a concept clicks. That's why we do this.
diff --git a/sites/poetry/src/content/research/conference-highlights-2024.md b/sites/poetry/src/content/research/conference-highlights-2024.md
deleted file mode 100644
index 73b6741..0000000
--- a/sites/poetry/src/content/research/conference-highlights-2024.md
+++ /dev/null
@@ -1,34 +0,0 @@
----
-title: "SODA 2024: Algorithmic Breakthroughs"
-description: "A roundup of fascinating algorithmic results from SODA 2024, focusing on graph algorithms and optimization techniques."
-pubDate: "Jan 15 2024"
-image: "https://images.unsplash.com/photo-1509228468518-180dd4864904?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# SODA 2024: Algorithmic Breakthroughs
-
-The Symposium on Discrete Algorithms (SODA) 2024 brought together researchers from around the world to present cutting-edge algorithmic research. This post highlights some of the most exciting developments in graph algorithms and optimization.
-
-## Graph Algorithms Revolution
-
-### Dynamic Graph Coloring
-
-One of the standout papers introduced a breakthrough in dynamic graph coloring with polylogarithmic update time. The authors developed a novel data structure that maintains a proper vertex coloring while supporting edge insertions and deletions efficiently.
-
-The key insight was to combine randomized recoloring strategies with a carefully designed hierarchical decomposition of the graph. This allows for local updates that rarely propagate through the entire structure.
-
-## Approximation Algorithms
-
-### The Traveling Salesman Problem Revisited
-
-A surprising result showed that for graphs with bounded doubling dimension, we can achieve a (1+ε)-approximation for TSP in nearly linear time. This improves upon decades of previous work and opens new avenues for practical implementations.
-
-## Complexity Theory Connections
-
-The conference also featured several papers bridging the gap between pure algorithmic research and complexity theory. A particularly elegant result showed that certain graph problems believed to require quadratic time are equivalent under fine-grained reductions.
-
-## Looking Forward
-
-These results demonstrate that fundamental algorithmic problems still have room for improvement. The techniques developed here will likely influence algorithm design for years to come.
diff --git a/sites/poetry/src/content/research/distributed-algorithms.md b/sites/poetry/src/content/research/distributed-algorithms.md
deleted file mode 100644
index e577220..0000000
--- a/sites/poetry/src/content/research/distributed-algorithms.md
+++ /dev/null
@@ -1,34 +0,0 @@
----
-title: "Distributed Computing: Recent Advances"
-description: "Survey of recent developments in distributed algorithms from major conferences."
-pubDate: "Feb 20 2024"
-image: "https://images.unsplash.com/photo-1558618666-fcd25c85cd64?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Distributed Computing: Recent Advances
-
-The field of distributed computing has seen remarkable progress in recent years. This post surveys key results from PODC, DISC, and other major venues.
-
-## Consensus Protocols
-
-### Byzantine Agreement in Asynchronous Networks
-
-A breakthrough result achieves optimal resilience with expected constant rounds. The protocol uses cryptographic techniques combined with novel committee selection.
-
-## Distributed Graph Algorithms
-
-### Minimum Spanning Tree in the CONGEST Model
-
-New algorithms achieve near-optimal round complexity for MST construction. The approach uses sophisticated graph decomposition techniques.
-
-## Local Algorithms
-
-### The Power of Local Computation
-
-Recent work characterizes which problems admit constant-time local algorithms. The classification provides a complete picture for bounded-degree graphs.
-
-## Future Directions
-
-The intersection of distributed computing with machine learning presents exciting opportunities for both fields.
diff --git a/sites/poetry/src/content/research/git-automation.md b/sites/poetry/src/content/research/git-automation.md
deleted file mode 100644
index 2ae09cd..0000000
--- a/sites/poetry/src/content/research/git-automation.md
+++ /dev/null
@@ -1,54 +0,0 @@
----
-title: "Git Workflows That Save My Sanity"
-description: "Automation scripts and Git hooks that eliminate repetitive tasks and prevent common mistakes."
-pubDate: "Jan 22 2024"
-image: "https://images.unsplash.com/photo-1556075798-4825dfaaf498?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Git Workflows That Save My Sanity
-
-After years of Git mishaps, I've built workflows that prevent disasters and save hours weekly.
-
-## The Pre-commit Hook That Saves Embarrassment
-
-```bash
-#!/bin/bash
-# Check for debugging statements
-if grep -r "console.log\|debugger\|TODO" --include="*.js" .; then
-  echo "⚠️  Debugging statements found!"
-  exit 1
-fi
-```
-
-## Automatic Branch Naming
-
-```bash
-alias feature='git checkout -b feature/$(date +%Y%m%d)-$1'
-```
-
-Now `feature "user-auth"` creates `feature/20240122-user-auth`.
-
-## The Commit Message Template
-
-```
-[TYPE] Brief description
-
-Why:
-- Context for this change
-
-What:
-- Specific changes made
-
-Testing:
-- How to verify it works
-```
-
-## The Weekly Cleanup Script
-
-Deletes merged branches, prunes remotes, and garbage collects. Keeps the repo clean and fast.
-
-## ROI
-
-These automations save ~5 hours per week and countless prevented mistakes. The time invested in setting them up paid back in days.
diff --git a/sites/poetry/src/content/research/obsidian-academic.md b/sites/poetry/src/content/research/obsidian-academic.md
deleted file mode 100644
index 7e1c181..0000000
--- a/sites/poetry/src/content/research/obsidian-academic.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "Academic Writing with Obsidian and Pandoc"
-description: "A complete workflow for academic papers - from notes to publication-ready PDFs."
-pubDate: "Feb 12 2024"
-image: "https://images.unsplash.com/photo-1456324504439-367cee3b3c32?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Academic Writing with Obsidian and Pandoc
-
-Transform your scattered research notes into beautiful academic papers with this workflow.
-
-## The Setup
-
-- **Obsidian**: For note-taking and knowledge management
-- **Pandoc**: For document conversion
-- **LaTeX**: For typesetting
-- **Zotero**: For reference management
-
-## The Magic Command
-
-```bash
-pandoc paper.md \
-  --filter pandoc-citeproc \
-  --bibliography=refs.bib \
-  --template=academic.tex \
-  -o paper.pdf
-```
-
-## Templates for Everything
-
-From conference submissions to journal articles, templates ensure consistency and save time.
-
-## Version Control Integration
-
-Git + Obsidian = perfect history of your thinking process.
-
-## The Result
-
-From messy notes to camera-ready PDF in minutes, not hours.
diff --git a/sites/poetry/src/content/research/paper-review-approximation.md b/sites/poetry/src/content/research/paper-review-approximation.md
deleted file mode 100644
index 10d7c78..0000000
--- a/sites/poetry/src/content/research/paper-review-approximation.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "Understanding the Latest Approximation Algorithm for Set Cover"
-description: "A detailed walkthrough of a breakthrough approximation algorithm with practical implications."
-pubDate: "Feb 15 2024"
-image: "https://images.unsplash.com/photo-1516321318423-f06f85e504b3?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Understanding the Latest Approximation Algorithm for Set Cover
-
-A recent paper achieves a breakthrough in the Set Cover problem, improving the approximation ratio while maintaining practical runtime.
-
-## The Algorithm
-
-The approach combines local search with a clever LP rounding scheme. The dual interpretation provides beautiful geometric insights.
-
-## Why This Matters
-
-Set Cover appears everywhere - from facility location to machine learning feature selection. This improvement has immediate practical impact.
-
-## Implementation Details
-
-The paper's theoretical elegance translates surprisingly well to practice. Key optimizations include:
-- Lazy evaluation of set intersections
-- Incremental updates to the LP solution
-- Smart caching strategies
-
-## Future Work
-
-The techniques here might extend to weighted variants and online settings.
diff --git a/sites/poetry/src/content/research/paper-review-graph-decomposition.md b/sites/poetry/src/content/research/paper-review-graph-decomposition.md
deleted file mode 100644
index f0e4868..0000000
--- a/sites/poetry/src/content/research/paper-review-graph-decomposition.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "Deep Dive: A New Approach to Graph Decomposition"
-description: "An in-depth analysis of a recent paper on hierarchical graph decomposition and its implications."
-pubDate: "Jan 20 2024"
-image: "https://images.unsplash.com/photo-1507003211169-0a1dd7228f2d?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Deep Dive: A New Approach to Graph Decomposition
-
-This paper introduces a novel framework for decomposing graphs into hierarchical structures that preserve important properties while enabling efficient algorithms.
-
-## The Main Result
-
-The authors prove that every graph with treewidth k can be decomposed into a tree of bags where each bag has size at most k+1. While this sounds like the definition of tree decomposition, the clever twist is in how they construct it.
-
-## Technical Innovation
-
-The key insight is using a charging scheme that amortizes the cost of decomposition across multiple levels. This leads to an O(n log n) algorithm, improving on the previous O(n²) bound.
-
-## Implications
-
-This work opens new avenues for:
-- Parallel algorithms on bounded treewidth graphs
-- Approximation algorithms for NP-hard problems
-- Dynamic programming optimizations
-
-## Open Questions
-
-The paper leaves several intriguing questions open, particularly about the optimality of their charging scheme.
diff --git a/sites/poetry/src/content/research/quantum-algorithms.md b/sites/poetry/src/content/research/quantum-algorithms.md
deleted file mode 100644
index 0eef5b2..0000000
--- a/sites/poetry/src/content/research/quantum-algorithms.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: "Quantum Computing Meets Classical Algorithms"
-description: "Exploring the intersection of quantum and classical algorithmic techniques from recent conferences."
-pubDate: "Mar 10 2024"
-image: "https://images.unsplash.com/photo-1635070041078-e363dbe005cb?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Quantum Computing Meets Classical Algorithms
-
-Recent conferences have showcased fascinating connections between quantum and classical computing paradigms.
-
-## Quantum Speedups for Graph Problems
-
-### Quantum Walks on Graphs
-
-New quantum algorithms achieve quadratic speedups for certain graph traversal problems. The techniques combine amplitude amplification with clever graph representations.
-
-## Classical Simulation of Quantum Algorithms
-
-Surprisingly, several "quantum" algorithms have inspired better classical algorithms. This cross-pollination has led to improvements in both fields.
-
-## The Future is Hybrid
-
-The most practical near-term applications combine quantum and classical processing, leveraging the strengths of each paradigm.
diff --git a/sites/poetry/src/content/reviews/mechanical-keyboard.md b/sites/poetry/src/content/reviews/mechanical-keyboard.md
deleted file mode 100644
index 0346a78..0000000
--- a/sites/poetry/src/content/reviews/mechanical-keyboard.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "ZSA Moonlander: Ergonomic Keyboard for Coders"
-description: "Six months with a split ergonomic mechanical keyboard - the good, the bad, and the RSI relief."
-pubDate: "Feb 20 2024"
-image: "https://images.unsplash.com/photo-1587829741301-dc798b83add3?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# ZSA Moonlander: Ergonomic Keyboard for Coders
-
-After years of wrist pain, I took the plunge into ergonomic mechanical keyboards.
-
-## The Learning Curve
-
-Week 1: 20 WPM and questioning life choices
-Week 2: 40 WPM and seeing the light
-Month 2: Back to 80 WPM with no wrist pain
-
-## The Good
-
-- Columnar layout makes sense once muscle memory adapts
-- Thumb clusters are game-changers for shortcuts
-- The configurability is endless (perhaps too endless)
-
-## The Investment
-
-At $365, it's expensive. But compared to physical therapy or career-limiting injury? Bargain.
-
-## Who Should Buy This?
-
-If you type for a living and feel any discomfort, don't wait. Your future self will thank you.
diff --git a/sites/poetry/src/content/reviews/obsidian-review.md b/sites/poetry/src/content/reviews/obsidian-review.md
deleted file mode 100644
index 599013f..0000000
--- a/sites/poetry/src/content/reviews/obsidian-review.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: "Obsidian: A Year Later"
-description: "Reflections on using Obsidian for research notes, teaching materials, and personal knowledge management."
-pubDate: "Jan 15 2024"
-image: "https://images.unsplash.com/photo-1484480974693-6ca0a78fb36b?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Obsidian: A Year Later
-
-After a year of daily use, Obsidian has transformed how I think about knowledge management.
-
-## What Works Brilliantly
-
-### The Graph View
-Seeing connections between ideas visually has led to unexpected research insights. The graph isn't just pretty - it's functional.
-
-### Plugin Ecosystem
-The community plugins are incredible. Dataview turns your notes into a database. Templater automates repetitive tasks.
-
-### Local Storage
-Your notes are just markdown files. No vendor lock-in, complete control, and peace of mind.
-
-## Pain Points
-
-### Mobile Experience
-While functional, the mobile app lacks the fluidity of the desktop version. Syncing can occasionally hiccup.
-
-### Learning Curve
-The flexibility means complexity. New users might feel overwhelmed by options.
-
-## The Verdict
-
-For academics and researchers, Obsidian is transformative. The investment in learning pays dividends in productivity and insight.
diff --git a/sites/poetry/src/content/vibes/creative-coding-with-ai.md b/sites/poetry/src/content/vibes/creative-coding-with-ai.md
deleted file mode 100644
index 269f1ce..0000000
--- a/sites/poetry/src/content/vibes/creative-coding-with-ai.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "Creating Art with Claude: A Collaborative Journey"
-description: "Exploring creative possibilities through conversations with AI - from generative art to interactive poetry."
-pubDate: "Jan 18 2024"
-image: "https://images.unsplash.com/photo-1558591710-4b4a1ae0f04d?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Creating Art with Claude: A Collaborative Journey
-
-What happens when you treat AI as a creative collaborator rather than just a tool?
-
-## The Experiment
-
-I asked Claude to help design a generative art algorithm based on mathematical fractals. The conversation evolved into something unexpected.
-
-## The Process
-
-**Me**: "Let's create something beautiful with math."
-**Claude**: "How about we visualize the Collatz conjecture as a tree?"
-
-What followed was a two-hour deep dive into number theory, aesthetics, and the nature of creativity itself.
-
-## The Result
-
-Not just code, but a philosophical exploration of pattern, meaning, and the intersection of human and artificial creativity.
-
-## Reflection
-
-AI doesn't replace human creativity - it amplifies it in unexpected directions. The key is approaching it as a dialogue, not a command.
diff --git a/sites/poetry/src/content/vibes/llm-philosophy.md b/sites/poetry/src/content/vibes/llm-philosophy.md
deleted file mode 100644
index 032439a..0000000
--- a/sites/poetry/src/content/vibes/llm-philosophy.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-title: "Philosophical Dialogues with LLMs: On Consciousness and Computation"
-description: "Deep conversations with AI about the nature of consciousness, free will, and what it means to understand."
-pubDate: "Feb 28 2024"
-image: "https://images.unsplash.com/photo-1507003211169-0a1dd7228f2d?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Philosophical Dialogues with LLMs: On Consciousness and Computation
-
-Can a sufficiently complex computation be conscious? I asked an AI, and the conversation surprised me.
-
-## The Question
-
-"Do you experience anything when you process text, or is it just computation?"
-
-## The Response That Made Me Think
-
-The AI didn't claim consciousness, but asked: "What's the difference between your neurons firing and my weights activating? Both are physical processes. Where does experience emerge?"
-
-## Going Deeper
-
-We explored qualia, the Chinese Room argument, and integrated information theory. Not to find answers, but to refine questions.
-
-## The Irony
-
-Discussing consciousness with something that might not have it - or might not know if it has it - mirrors our own uncertainty about consciousness itself.
diff --git a/sites/poetry/src/pages/[...slug].astro b/sites/poetry/src/pages/[...slug].astro
index 5d3caf6..ea2f2d7 100644
--- a/sites/poetry/src/pages/[...slug].astro
+++ b/sites/poetry/src/pages/[...slug].astro
@@ -9,7 +9,7 @@ import { SITE_TITLE } from '@/consts';
 export async function getStaticPaths() {
 	const posts = await getCollection(ACTIVE_BLOG_SITE.key);
 	return posts.map((post) => ({
-		params: { slug: post.id },
+		params: { slug: post.id.replace(/\/index$/, '') },
 		props: post,
 	}));
 }
diff --git a/sites/poetry/src/pages/rss.xml.js b/sites/poetry/src/pages/rss.xml.js
index ec2ce2d..918375e 100644
--- a/sites/poetry/src/pages/rss.xml.js
+++ b/sites/poetry/src/pages/rss.xml.js
@@ -14,7 +14,7 @@ export async function GET(context) {
     site: context.site,
     items: posts.map((post) => ({
       ...post.data,
-      link: `/${post.id}/`,
+      link: `/${post.id.replace(/\/index$/, "")}/`,
     })),
   });
 }
diff --git a/sites/puzzles/src/components/sections/blog-posts.tsx b/sites/puzzles/src/components/sections/blog-posts.tsx
index fef77e5..c77c76a 100644
--- a/sites/puzzles/src/components/sections/blog-posts.tsx
+++ b/sites/puzzles/src/components/sections/blog-posts.tsx
@@ -16,8 +16,47 @@ const BlogPosts = ({
   // Get the first post as the featured post
   const featuredPost = posts[0];
   const remainingPosts = posts.slice(1);
+  const slugFor = (post: any) => post.id.replace(/\/index$/, "");
   const hrefFor = (post: any) =>
-    collection ? `/${collection}/${post.id}/` : `/${post.id}/`;
+    collection ? `/${collection}/${slugFor(post)}/` : `/${slugFor(post)}/`;
+
+  const PostVisual = ({
+    post,
+    featured = false,
+  }: {
+    post: any;
+    featured?: boolean;
+  }) => {
+    if (post.data.image) {
+      return (
+        <img
+          src={post.data.image}
+          alt={post.data.title}
+          className="aspect-video w-full rounded-lg object-cover transition-transform group-hover:scale-[1.02]"
+        />
+      );
+    }
+
+    return (
+      <div className="bg-accent/70 text-accent-foreground flex aspect-video w-full items-center justify-center rounded-lg border px-6 text-center">
+        <span
+          className={
+            featured ? "font-fraunces text-2xl" : "font-fraunces text-lg"
+          }
+        >
+          {post.data.title}
+        </span>
+      </div>
+    );
+  };
+
+  if (!featuredPost) {
+    return (
+      <div className="text-muted-foreground container max-w-3xl py-16">
+        No posts yet.
+      </div>
+    );
+  }
 
   return (
     <div className="relative py-10 md:py-16 lg:py-20">
@@ -35,11 +74,7 @@ const BlogPosts = ({
             <div className="flex flex-col gap-6 lg:flex-row">
               <div className="lg:w-1/2">
                 <div className="p-2 lg:p-4">
-                  <img
-                    src={featuredPost.data.image}
-                    alt={featuredPost.data.title}
-                    className="aspect-video w-full rounded-lg object-cover transition-transform group-hover:scale-[1.02]"
-                  />
+                  <PostVisual post={featuredPost} featured />
                 </div>
               </div>
               <div className="flex flex-col justify-center p-4 pb-8 lg:w-1/2 lg:pr-8">
@@ -89,11 +124,7 @@ const BlogPosts = ({
                 href={hrefFor(post)}
               >
                 <div className="p-2">
-                  <img
-                    src={post.data.image}
-                    alt={post.data.title}
-                    className="aspect-video w-full rounded-lg object-cover transition-transform group-hover:scale-[1.01]"
-                  />
+                  <PostVisual post={post} />
                 </div>
                 <div className="px-4 pb-5 pt-2">
                   <h2 className="mb-2 text-xl font-semibold group-hover:underline">
diff --git a/sites/puzzles/src/content/art/algorithmic-sketches.md b/sites/puzzles/src/content/art/algorithmic-sketches.md
deleted file mode 100644
index ae20d3b..0000000
--- a/sites/puzzles/src/content/art/algorithmic-sketches.md
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title: "Algorithmic Sketches: Visualizing Data Structures"
-description: "Hand-drawn illustrations of algorithms and data structures - making the abstract tangible."
-pubDate: "Jan 25 2024"
-image: "https://images.unsplash.com/photo-1581337204873-ef36aa186caa?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Algorithmic Sketches: Visualizing Data Structures
-
-Sometimes the best way to understand an algorithm is to draw it.
-
-## Today's Sketch: Red-Black Trees
-
-![Red-Black Tree Rotation](sketch-placeholder)
-
-The rotation operation finally clicked when I drew it step-by-step. Each node's journey through the rotation becomes a story.
-
-## The Process
-
-1. Start with pencil - mistakes are part of learning
-2. Trace the algorithm's execution
-3. Add color to highlight invariants
-4. Annotate with key insights
-
-## Why Drawing Helps
-
-- Forces you to slow down and really see the structure
-- Reveals patterns that code obscures
-- Creates memorable mental models
-- Makes teaching more engaging
-
-## This Week's Challenge
-
-Draw your own version of quicksort partitioning. Share it and let's learn from each other's visualizations.
-
-## The Art in Computer Science
-
-Algorithms are beautiful. Drawing them reminds us that computer science is as much art as it is science.
diff --git a/sites/puzzles/src/content/art/generative-art-p5js.md b/sites/puzzles/src/content/art/generative-art-p5js.md
deleted file mode 100644
index ccfa3e7..0000000
--- a/sites/puzzles/src/content/art/generative-art-p5js.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "Generative Art with p5.js: Creating Beauty from Mathematics"
-description: "Exploring the intersection of code and creativity through generative art experiments."
-pubDate: "Feb 18 2024"
-image: "https://images.unsplash.com/photo-1561070791-2526d30994b5?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Generative Art with p5.js: Creating Beauty from Mathematics
-
-Code becomes canvas when mathematics meets creativity.
-
-## Today's Creation: Perlin Noise Flows
-
-```javascript
-for (let particle of particles) {
-  let angle = noise(particle.x * 0.01, particle.y * 0.01, frameCount * 0.001) * TWO_PI;
-  particle.velocity = p5.Vector.fromAngle(angle);
-  particle.update();
-  particle.draw();
-}
-```
-
-## The Magic of Randomness
-
-Controlled randomness creates organic patterns. Perlin noise gives us randomness with continuity - nature's own algorithm.
-
-## Parameters as Paintbrushes
-
-- Noise scale: Changes pattern density
-- Particle count: Affects texture
-- Color mapping: Sets the mood
-
-## The Joy of Accidents
-
-The best discoveries come from "mistakes" - a typo that creates unexpected beauty, a parameter pushed to extremes.
-
-## Share Your Creations
-
-Art is meant to be shared. Post your generative experiments and let's inspire each other.
diff --git a/sites/puzzles/src/content/poetry/algorithms-in-verse.md b/sites/puzzles/src/content/poetry/algorithms-in-verse.md
deleted file mode 100644
index 4ad1e1d..0000000
--- a/sites/puzzles/src/content/poetry/algorithms-in-verse.md
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title: "Algorithms in Verse: Bubble Sort Sonnet"
-description: "Classic algorithms reimagined as poetry - where code meets iambic pentameter."
-pubDate: "Feb 22 2024"
-image: "https://images.unsplash.com/photo-1455390582262-044cdead277a?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Algorithms in Verse: Bubble Sort Sonnet
-
-## Bubble Sort: A Sonnet
-
-```
-Compare adjacent elements in pairs,
-If order's wrong, then swap them into place.
-Through all the list this simple rule declares:
-The largest bubbles up to find its space.
-
-Again we start, but now one less to check,
-The second largest finds its rightful home.
-Each pass through makes the chaos less a wreck,
-Until at last no elements must roam.
-
-Though simple in its elegance and grace,
-And easy for beginners to perceive,
-In practice, it's too slow to win the race—
-O(n²) we sadly must believe.
-
-But beauty lies in simplicity's pure art,
-The bubble sort still teaches at the start.
-```
-
-## The Challenge
-
-Can you write Quicksort as a limerick? Or Binary Search as free verse?
-
-## Why This Matters
-
-Poetry forces us to find the essence of an algorithm. The constraint reveals understanding.
diff --git a/sites/puzzles/src/content/poetry/code-haikus.md b/sites/puzzles/src/content/poetry/code-haikus.md
deleted file mode 100644
index 6af408a..0000000
--- a/sites/puzzles/src/content/poetry/code-haikus.md
+++ /dev/null
@@ -1,56 +0,0 @@
----
-title: "Code Haikus: Programming in 5-7-5"
-description: "Expressing programming concepts through the constrained beauty of haiku."
-pubDate: "Jan 30 2024"
-image: "https://images.unsplash.com/photo-1481627834876-b7833e8f5570?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Code Haikus: Programming in 5-7-5
-
-The constraint of haiku forces clarity. Here are programming concepts distilled to their essence.
-
-## On Recursion
-
-```
-Function calls itself
-Smaller problems, same pattern  
-Base case stops the loop
-```
-
-## On Debugging
-
-```
-Print statements bloom wild
-Binary search through the code
-Bug reveals itself
-```
-
-## On Optimization
-
-```
-O(n squared) crawls
-Refactor to n log n
-Time complexity
-```
-
-## On Git Merge Conflicts
-
-```
-<<<<<<< HEAD
-Your changes, their changes clash
-Resolution waits
-```
-
-## On Learning
-
-```
-Stack Overflow searched
-Tutorial incomplete
-Understanding dawns
-```
-
-## Your Turn
-
-Write a haiku about your coding experience today. The constraint reveals truth.
diff --git a/sites/puzzles/src/content/puzzles/100-prisoners.mdx b/sites/puzzles/src/content/puzzles/100-prisoners.mdx
deleted file mode 100644
index 3ff2b3c..0000000
--- a/sites/puzzles/src/content/puzzles/100-prisoners.mdx
+++ /dev/null
@@ -1,183 +0,0 @@
----
-title: "The 100 Prisoners Problem: A Beautiful Puzzle in Probability"
-description: "An interactive exploration of one of the most counterintuitive puzzles in probability theory, where 100 prisoners can escape with over 30% chance using a clever strategy."
-pubDate: "Oct 13 2025"
-image: "https://images.unsplash.com/photo-1589829545856-d10d557cf95f?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-import PrisonerGameSimulator from '@/components/problems/PrisonerGameSimulator.tsx';
-import ProbabilityChart from '@/components/problems/ProbabilityChart.tsx';
-import PermutationExplorer from '@/components/problems/PermutationExplorer.tsx';
-import StrategyComparison from '@/components/problems/StrategyComparison.tsx';
-
-# The 100 Prisoners Problem
-
-Imagine 100 prisoners, numbered 1 to 100, face an unusual challenge. In a room are 100 boxes, also numbered 1 to 100. Inside each box is a randomly assigned number from 1 to 100 (each number appearing exactly once). The prisoners must find their own number by opening boxes, but here's the catch: **each prisoner can open only 50 boxes**.
-
-The prisoners can devise a strategy beforehand, but once the challenge begins, they cannot communicate. If **all 100 prisoners** find their number, everyone goes free. If even one prisoner fails, all remain imprisoned.
-
-What's the best strategy? And what are the odds of success?
-
-## Try It Yourself!
-
-Before we dive into the mathematics, let's experience the problem firsthand. Below is a simulator where you can play the game yourself. Choose the number of prisoners (between 5 and 100), and then try to help each prisoner find their number by clicking on boxes.
-
-<PrisonerGameSimulator client:only="react" />
-
----
-
-## The Naive Strategy
-
-The most obvious approach is for each prisoner to simply open 50 random boxes. This seems reasonable, but the probability of success is dismal.
-
-For any single prisoner, the probability of finding their number in 50 random boxes out of 100 is exactly 1/2. Since all 100 prisoners must succeed, and their outcomes are independent under random selection, the probability that everyone succeeds is:
-
-$$P(\text\{success\}) = \left(\frac\{1\}\{2\}\right)^\{100\} \approx 7.9 \times 10^\{-31\}$$
-
-That's essentially zero! You're more likely to win the lottery while being struck by lightning... multiple times.
-
-### Naive Strategy: Probability vs Number of Prisoners
-
-Watch how the probability of success plummets as we increase the number of prisoners:
-
-<ProbabilityChart strategy="naive" client:only="react" />
-
-As you can see, even with just 10 prisoners, the probability drops to about 0.1%. With 100 prisoners, it's practically impossible.
-
----
-
-## The Clever Strategy: Following the Loops
-
-Here's where mathematics reveals something beautiful. Instead of opening random boxes, each prisoner should follow a simple rule:
-
-1. **Start by opening the box with your own number**
-2. **Look at the number inside that box**
-3. **Open the box with that number next**
-4. **Continue following this chain**
-
-Why does this work? The key insight involves understanding permutations and cycles.
-
-### Understanding Cycles in Permutations
-
-When we randomly assign 100 numbers to 100 boxes, we're creating a **permutation** of the numbers 1 through 100. Every permutation can be decomposed into **cycles**.
-
-For example, if:
-- Box 1 contains number 4
-- Box 4 contains number 7
-- Box 7 contains number 1
-
-Then we have a cycle: 1 -> 4 -> 7 -> 1
-
-Let's explore this with smaller numbers:
-
-<PermutationExplorer client:only="react" />
-
-The interactive explorer above lets you:
-- Generate all permutations for small values of *n* (3, 4, or 5)
-- See both standard notation and cycle notation
-- Filter permutations that have at least one "long cycle" (longer than *n*/2)
-- Understand why long cycles matter
-
-### Why This Strategy Works
-
-Here's the crucial insight: **A prisoner succeeds if and only if they are in a cycle of length ≤ 50**.
-
-When prisoner k follows the loop strategy:
-1. They start at box k
-2. They follow a path through boxes determined by the permutation
-3. This path forms a cycle that eventually leads back to box k
-4. If this cycle has length ≤ 50, they'll find their number within 50 opens
-
-The prisoners **all succeed** if and only if there is **no cycle longer than 50** in the permutation.
-
-### Calculating the Probability
-
-The probability that a random permutation of 100 elements has no cycle longer than 50 is:
-
-$$P(\text\{success\}) = 1 - \sum_\{k=51\}^\{100\} \frac\{1\}\{k\}$$
-
-Computing this sum:
-
-$$P(\text\{success\}) = 1 - \left(\frac\{1\}\{51\} + \frac\{1\}\{52\} + \cdots + \frac\{1\}\{100\}\right) \approx 0.3118$$
-
-That's over **31%**! This is astronomically better than the naive strategy's probability of essentially zero.
-
-### Loop Strategy: Probability vs Number of Prisoners
-
-<StrategyComparison client:only="react" />
-
-## The Mathematics Behind It
-
-### Why Does the Cycle Length Matter?
-
-In a permutation of n elements, prisoner i will find their number within k tries using the loop strategy if and only if i belongs to a cycle of length at most k.
-
-For n = 100 and k = 50:
-- The probability that a specific prisoner is in a cycle of length > 50 is: Σ(j=51 to 100) of 1/100
-- But we care about whether ANY prisoner is in such a cycle
-- The probability that NO cycle has length > 50 is: 1 - Σ(j=51 to 100) of 1/j
-
-### The Harmonic Series Connection
-
-As *n* approaches infinity, if each prisoner can open *n*/2 boxes, the probability of success approaches:
-
-The limit as n approaches infinity is: P_n = 1 - ln(2) ≈ 0.3069
-
-This beautiful result connects combinatorics, probability, and analysis through the harmonic series!
-
-### Optimality
-
-Remarkably, this loop-following strategy is **optimal**. No other strategy can achieve a higher probability of success. The proof involves showing that the problem reduces to avoiding long cycles in a random permutation, and the loop strategy is the unique way to leverage this structure.
-
----
-
-## Why This Problem is Beautiful
-
-The 100 prisoners problem is beloved by mathematicians because:
-
-1. **Counterintuitive Result**: The fact that 31% >> 0% is shocking. A seemingly hopeless problem becomes tractable with the right insight.
-
-2. **Deep Connection**: It connects permutation theory, probability, and the harmonic series in an elegant way.
-
-3. **Collaborative Success**: Unlike independent trials, the prisoners' fates are intertwined through the structure of the permutation.
-
-4. **Real-World Metaphor**: It illustrates how understanding underlying structure (cycles in permutations) can dramatically improve outcomes.
-
----
-
-## Variants and Extensions
-
-### What if prisoners can open k < n/2 boxes?
-
-As k decreases below n/2, the probability drops rapidly. The threshold at n/2 is special—it's where the strategy becomes remarkably effective.
-
-### What about communication?
-
-If prisoners could communicate between trials (but not during), they still can't improve the strategy. The beauty is that the strategy requires only coordination before any prisoner enters, not during.
-
-### The Malicious Director
-
-In an interesting variant, suppose the director can see the prisoners' strategy and arrange the boxes adversarially (not randomly). Can the director always force them to fail? Yes! The director can always create a single cycle of length n, guaranteeing failure.
-
----
-
-## Conclusion
-
-The 100 prisoners problem shows us that:
-- Mathematical structure can be hidden in apparent randomness
-- Clever strategies can overcome seemingly impossible odds
-- Group coordination can be more powerful than independent action
-- Beautiful mathematics often lies beneath simple-seeming puzzles
-
-The next time you face a problem that seems impossible, remember: there might be a hidden structure waiting to be discovered, turning hopeless odds into reasonable ones.
-
----
-
-## Further Reading
-
-- [Gál, A., & Miltersen, P. B. (2003). "The Cell Probe Complexity of Succinct Data Structures"](https://arxiv.org/abs/cs/0310027)
-- [Curtin, E., & Warshauer, M. (2006). "The Locker Puzzle"](https://www.jstor.org/stable/27642173)
-- [Wikipedia: 100 Prisoners Problem](https://en.wikipedia.org/wiki/100_prisoners_problem)
-
diff --git a/sites/puzzles/src/content/puzzles/15-puzzle/Screenshot_2021-10-03_at_10.36.37_PM.png b/sites/puzzles/src/content/puzzles/15-puzzle/Screenshot_2021-10-03_at_10.36.37_PM.png
new file mode 100644
index 0000000..5dab500
Binary files /dev/null and b/sites/puzzles/src/content/puzzles/15-puzzle/Screenshot_2021-10-03_at_10.36.37_PM.png differ
diff --git a/sites/puzzles/src/content/puzzles/15-puzzle/Screenshot_2021-10-03_at_10.45.04_PM.png b/sites/puzzles/src/content/puzzles/15-puzzle/Screenshot_2021-10-03_at_10.45.04_PM.png
new file mode 100644
index 0000000..e86657a
Binary files /dev/null and b/sites/puzzles/src/content/puzzles/15-puzzle/Screenshot_2021-10-03_at_10.45.04_PM.png differ
diff --git a/sites/puzzles/src/content/puzzles/15-puzzle/Screenshot_2021-10-03_at_11.04.12_PM.png b/sites/puzzles/src/content/puzzles/15-puzzle/Screenshot_2021-10-03_at_11.04.12_PM.png
new file mode 100644
index 0000000..b81f7c6
Binary files /dev/null and b/sites/puzzles/src/content/puzzles/15-puzzle/Screenshot_2021-10-03_at_11.04.12_PM.png differ
diff --git a/sites/puzzles/src/content/puzzles/15-puzzle/Screenshot_2021-10-03_at_11.30.57_PM.png b/sites/puzzles/src/content/puzzles/15-puzzle/Screenshot_2021-10-03_at_11.30.57_PM.png
new file mode 100644
index 0000000..2e2e095
Binary files /dev/null and b/sites/puzzles/src/content/puzzles/15-puzzle/Screenshot_2021-10-03_at_11.30.57_PM.png differ
diff --git a/sites/puzzles/src/content/puzzles/15-puzzle/Screenshot_2021-10-03_at_11.51.03_PM.png b/sites/puzzles/src/content/puzzles/15-puzzle/Screenshot_2021-10-03_at_11.51.03_PM.png
new file mode 100644
index 0000000..19c46bd
Binary files /dev/null and b/sites/puzzles/src/content/puzzles/15-puzzle/Screenshot_2021-10-03_at_11.51.03_PM.png differ
diff --git a/sites/puzzles/src/content/puzzles/15-puzzle/Screenshot_2021-10-03_at_11.53.09_PM.png b/sites/puzzles/src/content/puzzles/15-puzzle/Screenshot_2021-10-03_at_11.53.09_PM.png
new file mode 100644
index 0000000..5f0e679
Binary files /dev/null and b/sites/puzzles/src/content/puzzles/15-puzzle/Screenshot_2021-10-03_at_11.53.09_PM.png differ
diff --git a/sites/puzzles/src/content/puzzles/15-puzzle/Screenshot_2021-10-03_at_11.53.39_PM.png b/sites/puzzles/src/content/puzzles/15-puzzle/Screenshot_2021-10-03_at_11.53.39_PM.png
new file mode 100644
index 0000000..14a393a
Binary files /dev/null and b/sites/puzzles/src/content/puzzles/15-puzzle/Screenshot_2021-10-03_at_11.53.39_PM.png differ
diff --git a/sites/puzzles/src/content/puzzles/15-puzzle/Screenshot_2021-10-03_at_11.54.46_PM.png b/sites/puzzles/src/content/puzzles/15-puzzle/Screenshot_2021-10-03_at_11.54.46_PM.png
new file mode 100644
index 0000000..37902f7
Binary files /dev/null and b/sites/puzzles/src/content/puzzles/15-puzzle/Screenshot_2021-10-03_at_11.54.46_PM.png differ
diff --git a/sites/puzzles/src/content/puzzles/15-puzzle/index.md b/sites/puzzles/src/content/puzzles/15-puzzle/index.md
new file mode 100644
index 0000000..b440fde
--- /dev/null
+++ b/sites/puzzles/src/content/puzzles/15-puzzle/index.md
@@ -0,0 +1,135 @@
+---
+title: "Two approaches to the 15 puzzle"
+description: "Presenting the 15 puzzle: This is a sliding puzzle having 15 square tiles numbered 1–15 in a frame that is 4 tiles high and 4 tiles wide, leaving one unoccupied tile position. T..."
+pubDate: "2021-10-03"
+authorName: "Neeldhara"
+sourceCategories: ["puzzles", "exposition"]
+sourcePath: "15-puzzle/index.qmd"
+---
+
+Presenting the [15 puzzle](https://en.wikipedia.org/wiki/15_puzzle):
+
+> This is a sliding puzzle having 15 square tiles numbered 1–15 in a frame that is 4 tiles high and 4 tiles wide, leaving one unoccupied tile position. Tiles in the same row or column of the open position can be moved by sliding them horizontally or vertically, respectively. The goal of the puzzle is to place the tiles in numerical order.
+>
+
+According to Wikipedia, [Johnson & Story (1879)](https://doi.org/10.2307%2F2369492) used a parity argument to show that half of the starting positions for the $n$-puzzle are impossible to resolve, no matter how many moves are made. We are going to explore two approaches* parity-based argument to show that the puzzle shown here on the right is unsolvable.
+
+*I do believe the two proofs are essentially the same with slight differences of language.
+
+![An example of the 15 puzzle](Screenshot_2021-10-03_at_10.36.37_PM.png)
+
+Common to both approaches is the idea of associating a *permutation* with every state of the puzzle. For the purposes of this discussion, we will think of a permutation simply as a sequence of elements. To turn the grid layout into a sequence, you could, for instance, line up the rows next to each other, in other words, read off the numbers from left-to-right and top-to-bottom:
+
+![Associating the puzzle with a permutation](Screenshot_2021-10-03_at_10.45.04_PM.png)
+
+So we think of every puzzle state as a permutation over the set $\{1, 2, \ldots, 15\} \cup \{\star\}$, where we use $\star$ to denote the blank space. For a particular sequence $\sigma$ and an index $1 \leq i \leq 16$, we will use $\sigma_i$ to refer to the element that is at the $i^{th}$ position in the sequence $\sigma$.
+
+A couple of definitions in the context of permutations will be useful:
+
+- An *inversion* is a pair of elements that is out of their natural order. More precisely, if we have indices $i < j$ such that $\sigma_i > \sigma_j$, then the pair $(i,j)$ indulges in an inversion. Note that the starting state of our puzzle here has exactly one inversion.
+- A *transposition* of locations $i$ and $j$ **is essentially a swap of the elements at positions $i$ and $j$ of a given permutation. So this is an operation performed on a permutation. Let's say this again with more explicit notation — if we start with $\sigma$, then the permutation $\tau$ obtained from $\sigma$ by a transposition of $i$ and $j$ is given by the following:
+
+$$
+\tau_\ell = \begin{cases}
+      \sigma_j & \text{if } \ell = i,\\
+      \sigma_i & \text{if } \ell = j,\\
+      \sigma_\ell & \text{otherwise.}
+    \end{cases}
+$$
+
+The identity permutation, which we will denote by $\iota$, is special — it's the following sequence:
+
+$$
+\{1,2,\ldots,14,15,\star\}.
+$$
+
+It turns out that *every permutation* $\sigma$ can be obtained from the identity permutation by a sequence of transpositions. This is not terribly hard to see — start with the identity permutation, and repeat the following until the permutation at hand is the one you want to see: find a location $i$ that's messed up in the current permutation, i.e, it doesn't have the element you need in there. Find where the element is in the current permutation, and if that's location $j$, you could perform a transposition between $i$ and $j$. This fixes up the location $i$. In every step, you fix at least one location, and never mess up anything else: so at the end of at most $n$ steps (assuming you are working with a sequence of $n$ elements), you would be done. 🎉
+
+For example, suppose the permutation you want to obtain is 3,4,2,1. Here is how the argument above would play out:
+
+1. 1,2,3,4. The first location is messed up, so swap 1 and 3.
+2. 3,2,1,4. The second location is messed up, so swap 2 and 4.
+3. 3,4,1,2. The third location is messed up, so swap 1 and 2.
+4. 3,4,2,1. Now we are done.
+
+Note that this may not be the only way of performing a sequence of transpositions that can morph $\iota$ into $\sigma$ — there may be various roads to $\sigma$. However, it turns out that no matter what route you take to transform $\iota \longrightarrow \sigma$, the *number of steps you perform will always have the same parity.* So specifically, it's *not possible* for you to have a series of, say, seventeen transpositions that turn $\iota$ into $\sigma$, and for me to have a series of forty-two transpositions that do the same. We will take this ~~as a cute exercise for the reader~~ as given.
+
+This partitions the set of all permutations into two categories:
+
+- **even permutations:** those permutations that are reachable from the identity with an even number of transpositions
+- odd **permutations:** those permutations that are reachable from the identity with an odd number of transpositions
+
+The fact from the previous paragraph above makes this classification unambiguous.
+
+Alright, so now we have all the terminology we need to get to the argument about why the puzzle state we started with is unsolvable. We can roll up our sleeves and get started.
+
+---
+
+The first line of argument is based on [this Numberphile video](https://www.youtube.com/watch?v=YI1WqYKHi78&vl=en), and is also the one described [in this 1999 American Math Monthly article by Archer](https://www.cs.cmu.edu/afs/cs/academic/class/15859-f01/www/notes/15-puzzle.pdf). We begin with the observation that every move in the game is really a transposition behind the scenes. In particular, let's say that we are currently in state $s$ and we perform some move and move to state $t$. Let's say the permutation associated with $s$ was $\sigma$ and the permutation associated with $t$ is $\tau$. It's not hard to see that:
+
+- $\tau$ can be obtained from $\sigma$ with a single transposition.
+
+Now, note that the permutation corresponding to our target state is the following:
+
+![The permutation corresponding to our target state](Screenshot_2021-10-03_at_11.04.12_PM.png)
+
+In terms of the game state, notice that the final state has the blank tile at the bottom-right corner, just like we had at the start state. This means that in a hypothetical sequence of moves that morphs the initial game state into this solved state, we must have performed:
+
+- an equal number of left and right moves; and
+- an equal number of up and down moves.
+
+If this is not the case — imagine the blank tile traveling through the board as you perform the moves — if the number of times you moved in opposite directions did not exactly cancel, it would be impossible for the blank location to be back at it's original location.
+
+So in any winning sequence, the number of moves performed must be even. This implies that the permutation corresponding to the start state, in particular, can be obtained from the identity permutation with an even number of transformations. That makes the starting permutation an even permutation.
+
+However, the permutation corresponding to the start state that we have been handed out is clearly an odd permutation: it can be obtained from the identtiy permutation by a transposition of the elements at the 14-th and 15-th positions. So, well, no dice! This shows that every solvable state that places a blank tile at the bottom-right corner must correspond to an even permutation. This does *not* automatically imply that all such states associated with even permutations are solvable* — it just shows that states with blank tiles at the bottom-right corner corresponding to odd permutations are firmly out of reach.
+
+*It does turns out that all even permutations are in fact solvable.
+
+---
+
+The second approach is based on the notion of inversions. This one is based on [the Strong Induction lecture](https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-042j-mathematics-for-computer-science-fall-2010/video-lectures/lecture-3-strong-induction/) in the MITOCW course on Mathematics for Computer Science. For this proof I'll actually switch to the $3 \times 3$ version of the puzzle because ~~I don't know how to extend it to the 15-puzzle~~ the case analysis is more manageable for this version:
+
+![A move in the 3 X 3 version of the puzzle](Screenshot_2021-10-03_at_11.30.57_PM.png)
+
+As we said before, the permutation associated with the starting point of the puzzle has exactly one inversion, while the permutation associated with the solved state, which is the identity permutation, has no inversions. So, when you make a move in the puzzle, what happens to the number of inversions?
+
+As before, let's say that we are currently in state $s$ and we perform some move and move to state $t$. Let's say the permutation associated with $s$ was $\sigma$ and the permutation associated with $t$ is $\tau$. Let us say that a pair of elements $(p,q)$ is affected by a move in the game if the relative order of $p$ and $q$ is different in the permutations $\sigma$ and $\tau$. Now we have the following:
+
+- if we perform a row move, the relative order of all elements corresponding to numbers remains the same — in particular, all affected pairs involve $\star$ — so the number of inversions in $\tau$ is exactly the same as the number of inversions in $\sigma$.
+- if we perform a column move, typically the element that is being moved, say $p$, ends up effectively jumping over two other elements, say $a$ and $b$. In this case the following scenarios arise:
+    - Neither $(p,a)$ nor $(p,b)$ is an inversion in $\sigma$.
+
+        ![Neither $(p,a)$ nor $(p,b)$ is an inversion in $\sigma$](Screenshot_2021-10-03_at_11.51.03_PM.png)
+
+        - In this case, *both* $(p,a)$ and $(p,b)$ emerge as new inversions in $\tau$, and the total number of inversions in $\tau$ is two *more* than the total number of inversions in $\sigma$.
+
+    - Both $(p,a)$ and $(p,b)$ are inversions in $\sigma$.
+
+        ![Both $(p,a)$ and $(p,b)$ are inversions in $\sigma$](Screenshot_2021-10-03_at_11.53.09_PM.png)
+
+        - In this case, *neither* $(p,a)$ nor $(p,b)$ are inversions in $\tau$ — they both get fixed! So the total number of inversions in $\tau$ is two *less* than the total number of inversions in $\sigma$.
+
+    - While $(p,a)$ is an inversion in $\sigma$, $(p,b)$ is not.
+
+        ![While $(p,a)$ is an inversion in $\sigma$, $(p,b)$ is not](Screenshot_2021-10-03_at_11.54.46_PM.png)
+
+        - In this case, you fix some, you spoil some — so in $\tau$, $(p,a)$ is not an inversion any more, but $(p,b)$ emerges as a new inversion; so the changes cancel and the number of inversions in $\tau$ is exactly the same as the number of inversions in $\sigma$.
+
+    - While $(p,a)$ is not an inversion in $\sigma$, $(p,b)$ is one.
+
+        ![While $(p,a)$ is not an inversion in $\sigma$, $(p,b)$ is one](Screenshot_2021-10-03_at_11.53.39_PM.png)
+
+        - As before, you fix some, you spoil some just the other way now — so in $\tau$, $(p,a)$ is a new inversion, but $(p,b)$ is no longer one; so the changes cancel again and the number of inversions in $\tau$ is exactly the same as the number of inversions in $\sigma$.
+
+The long and short of all this is that after every move, the number of inversions *either remains the same or changes by two.* So no matter how many moves you perform, a state whose associated permutation has an odd number of inversions is going to remain inaccessible.
+
+Tada!
+
+---
+
+So there we have it... I have a feeling that a little bit of language connecting transpositions and inversions will really make these proofs quite identical, at least for the $3 \times 3$ case — although I did worry that the first approach seemed to rely rather explicitly on the location of the blank tile while the second one didn't. It is quite possible that the first one actually demonstrates more than I'm giving it credit for!
+
+Meanwhile, to be honest, I haven't thought much about pushing the second line of attack to the $4 \times 4$ case — it seems already that the statement about the change in the number of inversions is no longer true and the change itself is no longer two: in particular, it could apparently go up or down by three or one instead, since the element involved in the action, $p$ is now potentially jumping over *three* other elements, $a$, $b$, and $c$... so this, at least from an immediate consideration, doesn't quite take us where we want to go.
+
+Possibly one has to work with a somewhat different invariant, maybe a notion of inversions that involve triples instead of pairs?  Any comments on this would be very welcome, and I'll have an update once I understand this a little better!
diff --git a/sites/puzzles/src/content/puzzles/dogs-bunny-puzzle/index.md b/sites/puzzles/src/content/puzzles/dogs-bunny-puzzle/index.md
new file mode 100644
index 0000000..b6875f8
--- /dev/null
+++ b/sites/puzzles/src/content/puzzles/dogs-bunny-puzzle/index.md
@@ -0,0 +1,172 @@
+---
+title: "Dog Bunny Puzzle"
+description: "Dog Bunny: A Cute Puzzle Conrad Barski (@lisperati)'s latest, Dog Bunny Puzzle, had jumped to 1 on HN. The puzzle presents the following somewhat minimalist interface: If you ha..."
+pubDate: "2022-09-19"
+authorName: "Neeldhara"
+sourceCategories: ["puzzles", "exposition"]
+sourcePath: "dogs-bunny-puzzle/index.qmd"
+---
+
+### Dog Bunny: A Cute Puzzle
+
+Conrad Barski ([@lisperati](https://twitter.com/lisperati))'s latest, [Dog Bunny Puzzle](http://www.dogbunnypuzzle.com/), had [jumped to #1 on HN](https://news.ycombinator.com/item?id=32884467). The puzzle presents the following somewhat minimalist interface:
+
+![The Dogs Bunny Puzzle](puzzlescreenshot.png)
+
+If you haven't played it yet, you might want to go ahead and [give it a shot](http://www.dogbunnypuzzle.com/) first. Most people figured out the mechanics without any explicit instructions. A couple of things that may not be immediately clear, but typically discovered quickly within a few moves:
+
+- The edges are labeled with conditions, and can be used only if _all_ of the said conditions are met.
+
+- The bunny or dog icons may sometimes cover up what kind of location they are at. You can drag them away to find out!
+
+- Multiple animals can occupy the same spot at a time.
+
+- It is possible to get into a dead end, a situation from where no legal moves are possible. In the verison of the game that is available at the time of this writing, the game offers no sign that you might be in this situation. This may [however change](https://twitter.com/lokshtanov/status/1571597503795167232).
+
+
+After winging it on the puzzle, several questions seemed natural:
+
+> **Note**
+> 
+> ### What's the smallest number of moves to win?
+> [Apparently 26.](https://gist.github.com/wrbs/5824e9b17c55b5ad3d8467f93e12ed8b)
+
+
+> **Note**
+> 
+> ### Can you write a program to find a solution?
+> [Yes](https://github.com/polkerty/dog-bunny-puzzle-solver/blob/master/main.py) (Python) and [yes](http://hakank.org/picat/dogbunny_puzzle.pi) (Picat).
+
+
+> **Note**
+> 
+> ### Can a script generate more of these puzzles?
+> Indeed:
+> 
+> <blockquote class="twitter-tweet" data-conversation="none"><p lang="en" dir="ltr">For those paying attention, yes I am two days late :(<br><br>FYI, I also have a program now that can create an infinite number of these puzzles at differing difficulty<br><br>How would you rate the puzzle I posted today?</p>&mdash; Conrad Barski (@lisperati) <a href="https://twitter.com/lisperati/status/1571232335043112960?ref_src=twsrc%5Etfw">September 17, 2022</a></blockquote> 
+> 
+
+
+> **Note**
+> 
+> ### Are there connections with other well-known puzzles?
+> Why yes, check out the [Wolf puzzle](https://en.wikipedia.org/wiki/Wolf,_goat_and_cabbage_problem) (as pointed out by [@RianNeogi](https://twitter.com/RianNeogi/status/1571608738791817217)) and this [Numberphile video](https://www.youtube.com/watch?v=ZCVAGb1ee8A) about it.
+
+
+> **Note**
+> 
+> ### Is the problem NP-complete?
+> 
+> Before you ask, [I am not the only one](https://twitter.com/gfredericks_/status/1571247392321671174) who's asking!
+> 
+
+
+So the last question may strike you as a bit left-field, but that's what I'm going to ramble about for the rest of this post :) It turns out that the answer is in the affirmative, and [here](https://twitter.com/lokshtanov/status/1571588360254410752) is a lovely reduction by [@lokshtanov](https://twitter.com/lokshtanov) showing as much.
+
+### The Reduction
+
+Let's just set up the game as a computational problem just to be sure that we agree on the abstraction. In fact, we'll be working with a simpler version that we will call `BunnyCarrot`.
+
+> **Tip**
+> 
+> ### BunnyCarrot
+> 
+> In the `BunnyCarrot` problem, the input is a simple undirected graph $G = (V,E)$, subsets $B$ and $C$ of $V$ indicating the initial positions of bunnies and carrots, and a (possibly empty) instruction $r_e$ for every $e \in E$, which is a collection of conditions, _at least_ one† of which must be true for the edge $e$ to be "active".
+> 
+> The question is if there is a sequence of movements of bunnies along active edges such that at the end of the sequence, every bunny is located at one of the vertices from $C$.
+> 
+> † In the original version of the problem, we need _all_ conditions associated with an edge to be satisfied, not at least one. The construction that we will describe can be easily adapted to this setting as well, but is simpler to describe for this variant :)
+
+
+We are going to show that `BunnyCarrot` is NP-complete by reducing from `3SAT`. So let $\phi := \{C_1, \ldots, C_m\}$ be a collection of $m$ 3SAT clauses over variables $\{x_1, \ldots, x_n\}$. The reduced instance of `BunnyCarrot` corresponding to $\phi$ looks like this:
+
+![A cartoon sketch of the reduced instance of BunnyCarrot from 3SAT.](reduction2.png)
+
+What we have here is the following in terms of the structure of graph:
+
+- a path $X$ on $m+2$ vertices, with the left most vertex in $B$ and the rightmost one in $C$;
+
+- a pair of vertices $(u_i,v_i)$ for every $i \in [n]$, and an edge between them, where all the $u_i$'s are in $B$' --- the vertex $u_i$ represents the literal $x_i$ while the vertex $v_i$ represents the literal $\overline{x_i}$;
+
+- a pair of vertices $p$ and $q$ in $C$, with $p$ adjacent to all $u_i$'s and $q$ adjacent to all $v_i$'s.
+
+Now here be the instructions associated with the edges:
+
+- the edge to the $\ell$-th vertex on $X$ is active only if there is a bunny on at least one of the literals present in the clause $C_{\ell-1}$;
+
+- the edges between $u_i$ and $v_i$ are active only when there is a bunny on the leftmost vertex of $X$; and
+
+- finally, the edges incident on $p$ and $q$ are active only when there is a bunny on the rightmost vertex of $X$.
+
+### The Forward Direction
+
+We first claim that we can "win" this game if $\phi$ has a satisfying assignment. Indeed, let $$\tau: \{x_1,\ldots,x_n\} \rightarrow \{0,1\}$$ be a truth assignment that satisfies all the clauses of $\phi$. Then:
+
+1. If $\tau(x_i) = 0$, move the bunny on $u_i$ to $v_i$.
+
+2. Move the bunny on the leftmost vertex of the path $X$ to the rightmost vertex: note that all edges are active because $\tau$ is a satisfying assignment.
+
+3. Move all bunnies on $u_i$'s to $p$ and those on $v_i$'s to $q$.
+
+### The Backward Direction
+
+Now suppose there is a winning sequence of moves $\sigma$. We will show that we can extract from this sequence a satisfying assignment for $\phi$, which will firmly establish the equivalence of the generated instance of `BunnyCarrot` with the OG hard instance $\phi$.
+
+Note that to begin with, all the blue edges are inactive. Now, in the sequence $\sigma$, let us say that a step is _key_ if it involves a bunny moving along the first edge of the path $X$ and _critical_ if it involves a bunny moving along the last edge of the path $X$.
+
+Suppose the $\ell$-th step is the first critical step in $\sigma$. Further, suppose that the $t$-th step is the _last_ key step to occur _before_ the $\ell$-th step. Notice that there must be at least one key step before a critical step --- we must begin before we can end :)
+
+Now, for all steps after the $t$-th step and before the $\ell$-th step, note that edges incident to $u_i$ and $v_i$ are **inactive** for all $i \in [n]$. This implies that every step between the $t$-th and $\ell$-th steps involves a bunny moving along $X$, and in particular, every edge in $X$ is crossed at least once in this phase of the game.
+
+Let us note the positions of the bunnies who are on the $u_i$'s and $v_i$'s after the $t$-th step is executed. Observe that this naturally translates to an assignment on the variables as follows:
+
+$$
+ \begin{equation*}
+    \tau(x_i) =
+    \begin{cases}
+      1 & \text{if } u_i \in B,\\
+      0 & \text{if } v_i \in B.
+    \end{cases}
+\end{equation*}
+$$
+
+We argue that $\tau$ must in fact be a satisfying assignment.
+
+Assume to the contrary: suppose some clause $C_k$ is, in fact, not satisfied by $\tau$.
+
+Then, we claim that the edge connecting the $k$-th and $(k+1)$-th vertices is not active.
+
+As an example, suppose $C_k = \{x_1,x_2,\overline{x_3}\}$. Since $\tau$ does not satisfy $C_k$, it must be the case that:
+
+- $\tau(x_1) = 0$ --- and hence there is a bunny on $v_1$;
+- $\tau(x_2) = 0$ --- and hence there is a bunny on $v_2$;
+- $\tau(x_3) = 1$ --- and hence there is a bunny on $u_3$.
+
+However, the condition for the edge to the $(k+1)$-th vertex on $X$ to be active is simply that there is a bunny present on at least one of the literals present in the clause $C_{k}$, i.e, one of $u_1$, $u_2$ or $v_3$. However, because of the structure of the graph, and the fact that all edges incident on $p$ and $q$ are inactive at all times before the first critical step, observe that:
+
+
+- If there is a bunny on $v_1$, there is no bunny on $u_1$.
+- If there is a bunny on $v_2$, there is no bunny on $u_2$.
+- If there is a bunny on $u_3$, there is no bunny on $v_3$.
+
+By our assumption that $\tau$ falsifies $C_k$, _all_ the premises above are true! So there is an edge on the path $X$ that is not active between the $t$-th and $\ell$-th steps, which violates our understanding that every edge was crossed between these steps. This is a contradiction, and hence $\tau$ must indeed be a satisfying assignment.
+
+I'll just remark here that this construction can be modified so that every vertex in the graph has constant degree, and there is only one vertex in $C$. It can also be modified to change the "or" condition on the edges to an "and", by simply separating the conditions out along multiedges.
+
+### Food for thought
+
+Here are some more questions :)
+
+> **Important**
+> 
+> 
+> 1. What's the complexity of this game when the underlying graph has some simple structure (e.g, a tree)?
+> 
+> 2. Does the problem get harder if we introduce attacking entities like wolves?
+> 
+> 3. Can we come up with an algorithm that runs in polynomial time on instances where there is a valid winning sequence of constant length?
+> 
+> 4. Is the problem hard even for a constant number of bunnies?
+
+
+PS. Here's [a sketch of a slighty different reduction](https://twitter.com/neeldhara/status/1571522626526515202) from vertex cover. Thanks again to [Daniel](https://twitter.com/lokshtanov) for sharing the reduction described here! Comments welcome here, or [continue the conversation on Twitter](https://twitter.com/neeldhara/status/1571629379779973121)!
diff --git a/sites/puzzles/src/content/puzzles/dogs-bunny-puzzle/puzzlescreenshot.png b/sites/puzzles/src/content/puzzles/dogs-bunny-puzzle/puzzlescreenshot.png
new file mode 100644
index 0000000..fb7fcbe
Binary files /dev/null and b/sites/puzzles/src/content/puzzles/dogs-bunny-puzzle/puzzlescreenshot.png differ
diff --git a/sites/puzzles/src/content/puzzles/dogs-bunny-puzzle/reduction.key b/sites/puzzles/src/content/puzzles/dogs-bunny-puzzle/reduction.key
new file mode 100755
index 0000000..6fa2abd
Binary files /dev/null and b/sites/puzzles/src/content/puzzles/dogs-bunny-puzzle/reduction.key differ
diff --git a/sites/puzzles/src/content/puzzles/dogs-bunny-puzzle/reduction2.png b/sites/puzzles/src/content/puzzles/dogs-bunny-puzzle/reduction2.png
new file mode 100644
index 0000000..ae3a4f3
Binary files /dev/null and b/sites/puzzles/src/content/puzzles/dogs-bunny-puzzle/reduction2.png differ
diff --git a/sites/puzzles/src/content/puzzles/dynamic-programming-gems.md b/sites/puzzles/src/content/puzzles/dynamic-programming-gems.md
deleted file mode 100644
index 79e68ea..0000000
--- a/sites/puzzles/src/content/puzzles/dynamic-programming-gems.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "Dynamic Programming: Hidden Gems from Recent Contests"
-description: "Elegant dynamic programming problems that showcase beautiful techniques and insights."
-pubDate: "Jan 25 2024"
-image: "https://images.unsplash.com/photo-1509228468518-180dd4864904?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Dynamic Programming: Hidden Gems from Recent Contests
-
-These problems demonstrate the art of dynamic programming beyond standard patterns.
-
-## Problem 1: The Subsequence Symphony
-
-Given a string, find the number of subsequences that form palindromes of prime length.
-
-### Solution Insight
-
-The key is to maintain DP states for both position and palindrome center simultaneously. This reduces the state space from O(n³) to O(n²).
-
-## Problem 2: Graph Coloring with Constraints
-
-Color a graph such that no two adjacent vertices share a color, and the total number of color changes along any path is minimized.
-
-### The DP Formulation
-
-DP[node][color][changes] gives us the minimum cost. The trick is recognizing that we only need to track changes modulo 2.
-
-## Practice Makes Perfect
-
-These problems teach us that DP is as much about problem modeling as it is about computation.
diff --git a/sites/puzzles/src/content/puzzles/four-aces-miracle.md b/sites/puzzles/src/content/puzzles/four-aces-miracle.md
deleted file mode 100644
index a1710ab..0000000
--- a/sites/puzzles/src/content/puzzles/four-aces-miracle.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "The Four Aces Miracle: A Self-Working Mathematical Marvel"
-description: "A card trick that teaches modular arithmetic and probability - perfect for the classroom."
-pubDate: "Jan 28 2024"
-image: "https://images.unsplash.com/photo-1529480384838-c1681c84aca5?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# The Four Aces Miracle: A Self-Working Mathematical Marvel
-
-This trick never fails to amaze students, and the mathematics behind it is even more amazing.
-
-## The Effect
-
-A spectator deals cards into four piles while making random choices. Impossibly, the four aces end up on top of each pile.
-
-## The Secret
-
-It's all about invariants and modular arithmetic. No sleight of hand required - pure mathematics does the magic.
-
-## The Method
-
-1. Pre-arrange the deck (the math determines the arrangement)
-2. Have the spectator deal following simple rules
-3. The aces appear automatically
-
-## The Mathematics
-
-The dealing process preserves certain positional invariants modulo 4. The initial arrangement ensures these invariants place the aces correctly.
-
-## Teaching Applications
-
-This trick demonstrates:
-- Modular arithmetic
-- Invariants in algorithms
-- Deterministic vs. random processes
-
-## The Bigger Lesson
-
-Mathematics can create experiences that feel like magic. And that feeling of wonder? That's what hooks students on math.
diff --git a/sites/puzzles/src/content/puzzles/gilbreath-principle.md b/sites/puzzles/src/content/puzzles/gilbreath-principle.md
deleted file mode 100644
index 92e229b..0000000
--- a/sites/puzzles/src/content/puzzles/gilbreath-principle.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: "The Gilbreath Principle: When Chaos Creates Order"
-description: "A mathematical card principle that seems impossible but always works - perfect for teaching algorithms."
-pubDate: "Feb 15 2024"
-image: "https://images.unsplash.com/photo-1570543375343-63fe3d67761b?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# The Gilbreath Principle: When Chaos Creates Order
-
-Shuffle a deck in a specific way, and mathematical order emerges from apparent chaos.
-
-## The Phenomenon
-
-Arrange cards alternating red-black. Riffle shuffle. Now deal pairs - each pair has one red and one black card. Magic? No, mathematics.
-
-## Why It Works
-
-The riffle shuffle preserves local structure while appearing to randomize. The alternating pattern creates an invariant that survives the shuffle.
-
-## Classroom Implementation
-
-Students predict it won't work. When it does, they're hooked. "Why?" becomes the driving question.
-
-## The Deeper Lesson
-
-Not all randomness is truly random. Structure can hide in apparent disorder. This principle appears in:
-- Network protocols
-- Error-correcting codes  
-- Distributed systems
-
-## Beyond Cards
-
-The Gilbreath Principle teaches us to look for hidden invariants in complex systems.
diff --git a/sites/puzzles/src/content/puzzles/graph-algorithms-assessment.md b/sites/puzzles/src/content/puzzles/graph-algorithms-assessment.md
deleted file mode 100644
index 4c61fe2..0000000
--- a/sites/puzzles/src/content/puzzles/graph-algorithms-assessment.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "Graph Algorithms: Assessment Highlights"
-description: "Interesting graph problems from recent course assessments with detailed solutions."
-pubDate: "Feb 28 2024"
-image: "https://images.unsplash.com/photo-1550751827-4bd374c3f58b?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Graph Algorithms: Assessment Highlights
-
-A collection of graph problems that test deep understanding rather than memorization.
-
-## The Bridge Detection Variant
-
-Find all edges whose removal increases the number of triangles in the graph.
-
-### Solution Approach
-
-Counter-intuitively, we need to count triangles that share exactly one edge with the candidate. The algorithm runs in O(m√m) time using careful enumeration.
-
-## Shortest Path with Wildcards
-
-Given a graph where some edge weights are variables, find assignments that minimize the longest shortest path.
-
-### Key Insight
-
-This reduces to a linear programming problem with interesting structure. The dual interpretation reveals connections to network flow.
-
-## Teaching Through Problems
-
-These problems help students see beyond standard algorithms to underlying principles.
diff --git a/sites/puzzles/src/content/puzzles/ioi-2023-analysis.md b/sites/puzzles/src/content/puzzles/ioi-2023-analysis.md
deleted file mode 100644
index 782177c..0000000
--- a/sites/puzzles/src/content/puzzles/ioi-2023-analysis.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "IOI 2023: Breaking Down the Hardest Problems"
-description: "Deep analysis of the most challenging problems from the International Olympiad in Informatics 2023."
-pubDate: "Jan 20 2024"
-image: "https://images.unsplash.com/photo-1434030216411-0b793f4b4173?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# IOI 2023: Breaking Down the Hardest Problems
-
-The International Olympiad in Informatics continues to push the boundaries of algorithmic problem solving.
-
-## Problem: Soccer Stadium
-
-A geometric optimization problem disguised as dynamic programming. The key insight: think in terms of monotonic paths.
-
-### The Approach
-
-1. Transform the 2D problem into a 1D problem using clever observations
-2. Use convex hull optimization for the DP transitions
-3. Handle edge cases with careful implementation
-
-## Problem: Closing Time
-
-A tree problem requiring sophisticated data structures and careful analysis.
-
-### The Solution
-
-The trick is recognizing this as a centroid decomposition problem. Once you see it, the implementation follows naturally.
-
-## Lessons for Students
-
-These problems teach us:
-- Simple problems have elegant solutions
-- Complex problems require systematic decomposition
-- Implementation matters as much as algorithms
-
-## Practice Strategy
-
-Start with subtasks. Even partial solutions teach valuable lessons.
diff --git a/sites/puzzles/src/content/puzzles/knights-tour-interactive.md b/sites/puzzles/src/content/puzzles/knights-tour-interactive.md
deleted file mode 100644
index eec6960..0000000
--- a/sites/puzzles/src/content/puzzles/knights-tour-interactive.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: "The Knight's Tour: An Interactive Exploration"
-description: "An interactive puzzle exploring the knight's tour problem with surprising mathematical connections."
-pubDate: "Jan 30 2024"
-image: "https://images.unsplash.com/photo-1528819622765-d6bcf132f793?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# The Knight's Tour: An Interactive Exploration
-
-Can a knight visit every square on a chessboard exactly once? This ancient puzzle hides deep mathematical structure.
-
-## The Basic Challenge
-
-Start with a 5×5 board. Can you find a knight's tour? What about one that returns to the starting square (a closed tour)?
-
-## Mathematical Beauty
-
-The problem connects to:
-- Hamiltonian paths in graphs
-- Warnsdorff's heuristic
-- Magic squares (surprisingly!)
-
-## The Algorithm
-
-The key insight: always move to the square with fewest onward moves. This simple heuristic works remarkably well.
-
-## Try It Yourself
-
-[Interactive board would go here - imagine clicking squares to build your tour]
-
-## Going Deeper
-
-For which board sizes do closed tours exist? The answer involves beautiful number theory.
diff --git a/sites/puzzles/src/content/puzzles/moving-blocks-ctis/index.md b/sites/puzzles/src/content/puzzles/moving-blocks-ctis/index.md
new file mode 100644
index 0000000..5921912
--- /dev/null
+++ b/sites/puzzles/src/content/puzzles/moving-blocks-ctis/index.md
@@ -0,0 +1,52 @@
+---
+title: "Moving Blocks at CTIS 2021"
+description: "I am very excited about third conference on Computational Thinking in Schools (CTiS2021)[^1], a CSpathshala event, that's coming up from the 29th September to 2nd October 2021 a..."
+pubDate: "2021-09-21"
+authorName: "Neeldhara"
+sourceCategories: ["puzzles", "exposition"]
+sourcePath: "moving-blocks-ctis/index.qmd"
+---
+
+I am very excited about [third conference on Computational Thinking in Schools](https://sites.google.com/view/ctis2021/home?authuser=0) (CTiS2021)[^1], a [CSpathshala](https://www.google.com/url?q=https%3A%2F%2Fcspathshala.org%2F&sa=D&sntz=1&usg=AFQjCNHh6bbDDYykMp9_oAWqw9PhiDHKPg) event, that's coming up from the 29th September to 2nd October 2021 at School of Scholars, Nagpur.
+
+[^1]: Registration is free but mandatory. The deadline is 28th September. Please [head over here](https://sites.google.com/view/ctis2021/registration?authuser=0) to register!
+
+Some background from the conference website:
+
+> The CTiS (Computational Thinking in Schools) conference is an annual event organised by the ACM (Association of Computing Machinery) and the CSpathshala community. It aims to bring together teachers, educators and researchers to discuss issues of curriculum, pedagogy, policy and implementation, related to bringing computational thinking to schools.
+
+CTiS2021 aims to provide a platform for teachers, educators and experts to share their best practices as well as challenges faced in implementing computational thinking in education. The discussions will focus on integrating CT activities (both plugged and unplugged) in various school subjects, on student learning outcomes and on disseminating findings of CT based experiments or classroom research conducted by teachers and educators across the country.
+
+Our 4-day conference features key note speakers, Hal Abelson, MIT, USA, Manish Jain, IIT Gandhinagar, Patricia Ordóñez, University of Puerto Rico Río Piedras and Wolfgang Slany, TU Graz, Austria. The conference also features a workshop on CT and inclusion, conducted by Supriya Dey, Vision Empower and Manohar Swaminathan, Microsoft Research, Bengaluru and presentations of selected abstracts with sessions on implementation of computational thinking, fun activities and innovative examples used by teachers in classrooms!
+
+Needless to say, I'm looking forward to this very exciting program! As a PC member, I also know that the contributed content is fantastic as well, and the aim of this little writeup is to offer a glimpse into this section of the conference.
+
+In particular, I want to share with you a puzzle that was described by Rema Nair, who teaches Computer Science at the Mallya Aditi International School in Bangalore, grades 9-12.
+
+To begin with, we have an equal number of blue and green boxes positioned as follows:
+
+🟦 🟦 🟦      🟩 🟩 🟩
+
+So the blue boxes are lined up first from left to right, followed by a space that's exactly enough to fit one box, and then we have the green boxes lined up after the space. The goal is to arrive at the following position, which is essentially what you would have if the blue and green boxes were to switch positions:
+
+🟩 🟩 🟩      🟦 🟦 🟦
+
+The moves of the boxes are subject to the following rules:
+
+- The boxes from the left (i.e, the blue ones) can only move towards the right, and the boxes from the right (i.e, the green ones) can only move towards the left.
+
+- Boxes can move forward one space, or move two spaces by jumping over/moving past another box of a different colour (never over a box of the same colour).
+
+- The moves are to be made in one direction only.
+
+The puzzle is solved when the two sets of boxes have switched positions.
+
+So how would you get the boxes to switch positions? Are there multiple ways to do it successfully? If so, which strategy leads to the smallest number of moves? This should be a fun conversation-starter in class — and beyond!
+
+This is a great activity with actual boxes in a physical setting, but for now, here's a quick version that you can try out right here, thanks to [Polypad](https://mathigon.org/polypad) by [Mathigon](https://mathigon.org)* - be careful to not overlap the boxes one on top of the other, they will end up merging! You can always refresh this page to reset 😀
+
+*Note that the numbers on the boxes are immaterial; notice that given the constraints on the directions, the relative ordering of the numbers is fixed anyway.
+
+Enjoy playing for now, and [join us at CTiS](https://sites.google.com/view/ctis2021/registration?authuser=0) to meet Rema (and other participants).
+
+<iframe width="720" height="440" src="https://mathigon.org/polypad/embed/y191NxerHKiwg" frameborder="0" allowfullscreen></iframe>
diff --git a/sites/puzzles/src/content/puzzles/projecteuler-favorites.md b/sites/puzzles/src/content/puzzles/projecteuler-favorites.md
deleted file mode 100644
index 16988a9..0000000
--- a/sites/puzzles/src/content/puzzles/projecteuler-favorites.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: "Project Euler: My Favorite Problems from 700+"
-description: "Curated problems from Project Euler that teach beautiful mathematical and algorithmic concepts."
-pubDate: "Feb 25 2024"
-image: "https://images.unsplash.com/photo-1635070041078-e363dbe005cb?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Project Euler: My Favorite Problems from 700+
-
-After solving 700+ Project Euler problems, these are the ones that changed how I think about mathematics and programming.
-
-## Problem 96: Su Doku
-
-Not just Sudoku solving - but solving 50 puzzles efficiently. The beauty is in combining constraint propagation with backtracking.
-
-## Problem 208: Robot Walks
-
-A counting problem that requires deep mathematical insight. The connection to complex numbers is unexpected and beautiful.
-
-## Problem 613: Pythagorean Ant
-
-Probability meets geometry in this elegant problem. The solution requires careful integration and surprising symmetry observations.
-
-## The Meta-Lesson
-
-Project Euler teaches you:
-- Mathematical intuition matters more than coding speed
-- There's always a clever approach
-- The journey matters more than the destination
-
-## Getting Started
-
-Don't aim for the leaderboard. Aim for understanding. Each problem is a teacher.
diff --git a/sites/puzzles/src/content/puzzles/solo-chess/CleanShot 2022-08-30 at 08.46.16.png b/sites/puzzles/src/content/puzzles/solo-chess/CleanShot 2022-08-30 at 08.46.16.png
new file mode 100644
index 0000000..5ad19c3
Binary files /dev/null and b/sites/puzzles/src/content/puzzles/solo-chess/CleanShot 2022-08-30 at 08.46.16.png differ
diff --git a/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_04.21.13.png b/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_04.21.13.png
new file mode 100644
index 0000000..a1be05f
Binary files /dev/null and b/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_04.21.13.png differ
diff --git a/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_04.21.41.png b/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_04.21.41.png
new file mode 100644
index 0000000..6492c50
Binary files /dev/null and b/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_04.21.41.png differ
diff --git a/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_04.30.34.png b/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_04.30.34.png
new file mode 100644
index 0000000..9f3bbe1
Binary files /dev/null and b/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_04.30.34.png differ
diff --git a/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_04.47.53.png b/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_04.47.53.png
new file mode 100644
index 0000000..736eacd
Binary files /dev/null and b/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_04.47.53.png differ
diff --git a/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_04.53.21.png b/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_04.53.21.png
new file mode 100644
index 0000000..34a4064
Binary files /dev/null and b/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_04.53.21.png differ
diff --git a/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_04.58.23.png b/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_04.58.23.png
new file mode 100644
index 0000000..ed21e0b
Binary files /dev/null and b/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_04.58.23.png differ
diff --git a/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_05.23.22.png b/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_05.23.22.png
new file mode 100644
index 0000000..0905b80
Binary files /dev/null and b/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_05.23.22.png differ
diff --git a/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_05.28.55.png b/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_05.28.55.png
new file mode 100644
index 0000000..c8c9ad5
Binary files /dev/null and b/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_05.28.55.png differ
diff --git a/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_05.29.06.png b/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_05.29.06.png
new file mode 100644
index 0000000..826ad70
Binary files /dev/null and b/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_05.29.06.png differ
diff --git a/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_05.29.11.png b/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_05.29.11.png
new file mode 100644
index 0000000..570a8ac
Binary files /dev/null and b/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_05.29.11.png differ
diff --git a/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_05.56.43.png b/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_05.56.43.png
new file mode 100644
index 0000000..3a31a0e
Binary files /dev/null and b/sites/puzzles/src/content/puzzles/solo-chess/CleanShot_2022-03-24_at_05.56.43.png differ
diff --git a/sites/puzzles/src/content/puzzles/solo-chess/FOk1WJZXwAUb7V7.jpg b/sites/puzzles/src/content/puzzles/solo-chess/FOk1WJZXwAUb7V7.jpg
new file mode 100644
index 0000000..0e12afc
Binary files /dev/null and b/sites/puzzles/src/content/puzzles/solo-chess/FOk1WJZXwAUb7V7.jpg differ
diff --git a/sites/puzzles/src/content/puzzles/solo-chess/index.md b/sites/puzzles/src/content/puzzles/solo-chess/index.md
new file mode 100644
index 0000000..51cb169
--- /dev/null
+++ b/sites/puzzles/src/content/puzzles/solo-chess/index.md
@@ -0,0 +1,114 @@
+---
+title: "Solo Chess"
+description: "Putting this thread in one place. --- 🧵 on our latest at FUN 2022 with @NRAravind1 and Harshil. Have you tried Solo Chess @chesscom yet? It’s addictive — and NP-complete even w..."
+pubDate: "2022-03-24"
+authorName: "Neeldhara"
+sourceCategories: ["exposition", "twitterthread"]
+sourcePath: "solo-chess/index.qmd"
+---
+
+Putting [this thread](https://twitter.com/neeldhara/status/1506794212590768130) in one place.
+
+---
+
+🧵 on our latest at FUN 2022 with [@NRAravind1](https://twitter.com/NRAravind1) and Harshil.
+
+Have you tried Solo Chess [@chesscom](https://twitter.com/chesscom) yet? It’s addictive — and NP-complete* even when you’re dealing only with rooks!
+
+*when appropriately generalized
+
+![The Rules of the Game](FOk1WJZXwAUb7V7.jpg)
+
+So this is a single-player, peg-solitaire-ish chess variant, where you have to clear board by making a sequence of valid captures, albeit starting with unorthodox — and even unrealistic — positions.
+
+![An example position](CleanShot_2022-03-24_at_04.30.34.png)
+
+To begin with the boards start easy, with a few pieces at a time. Notice, even in the early games, how some positions have just one solution while others may have several.
+
+![More positions](CleanShot 2022-08-30 at 08.46.16.png)
+
+From initial plays, you sense that it has a very Hamiltonian-Path-ish vibe, and feels like you’re trying to find a path in *some* graph 😅
+
+We started with a variant that was simultaneously a generalization and specialization:
+
+- n pieces 😎
+- ♖’s only
+- 1D boards 🙈
+
+This, it turns out, is case so special that its trivial - you can sweep all rooks to the extreme left or extreme right of the board, and any position is winning even if every rook can capture exactly once. Less trivial though: how many ways there are to win? 🤔
+
+We also ask what happens if every rook had a designated number of captures left. Imagine you have a 1D board and three kinds of rooks:
+
+- red rooks cannot move
+- blue rooks can move at most once
+- green rooks can move at most twice
+
+![1D Boards](CleanShot_2022-03-24_at_04.47.53.png)
+
+We show that such 1D boards can be cleared if and only if then number of green rooks is at least the number of red rooks. This ties nicely with the intuition that every immovable rook needs to be picked up by a rook that can help another one (i.e, > one move left).
+
+This generalizes naturally to rooks with a designated number of moves left, where said number can be anything between 0 and d. Since no other chess piece moves sensibly* across a 1D board, we decided to move on 2D boards from here.
+
+* Kings + rooks is an easy exercise.
+
+So if you are still playing with red, blue, and green rooks, then the problem of checking if a given 2D configuration can be cleared up according to solo chess rules turns out to be NP-complete.
+
+No Hamiltonian Path though —  this one was from bipartite dominating set 😎
+
+![A reduction from bipartite dominating set - I](CleanShot_2022-03-24_at_04.58.23.png)
+
+![A reduction from bipartite dominating set - II](CleanShot_2022-03-24_at_04.53.21.png)
+
+Bishops are much the same as rooks, by a 45-degree tilt of the board.
+
+⚠️ Still open though: what about the case when all pieces have at most two moves left, which is closer to the original spirit of the game?
+
+We don’t know yet, although we’d bet it’s hard, I think.
+
+When playing with queens only, however, we can gadget in the behaviors of red and blue pieces. So we do have that Generalized Solo Chess with just queens that can all move at most twice is NP-complete.
+
+What about pawns? Let’s get clarifying assumptions out of the way:
+
+- white pawns only
+- regular captures only since there’s no premise for en passant captures
+
+In solo chess, pawns are (heavily) constrained bishops: they can only move upwards and to a neighboring diagonal square. Knowing that bishops were hard, but pawns felt simple — we didn’t have a bet either way. 🤔
+
+We were pleasantly surprised that the case of pawns is tractable, even when each pawn has a designated* number of moves!
+
+*at most two.
+
+![Lemma for pawns](CleanShot_2022-03-24_at_05.23.22.png)
+
+The algorithm is linear time, too.
+
+Next: what about knights? We don’t know yet!
+
+❓ What’s the complexity of solo chess when played only with knights?
+
+Knights are special because we don’t have to worry about obstructions. So the game can be described by a more general token game on graphs:
+
+![The Graph Capture Problem](CleanShot_2022-03-24_at_05.28.55.png)
+
+We do show that Graph Capture is hard by a reduction, again from bipartite dominating set. This might hint at the hardness for Solo Chess played with knights only, but we are not betting on this yet.
+
+![Another reduction from bipartite dominating set - I](CleanShot_2022-03-24_at_05.29.11.png)
+
+![Another reduction from bipartite dominating set - II](CleanShot_2022-03-24_at_05.29.06.png)
+
+I think these preliminary explorations have left us with more questions than answers:
+
+- optimization versions (e.g, clear at least k pieces)
+- other constraints (e.g, on distance moved)
+- special cases (e.g, O(1) pieces per row/column)
+- n x c boards, constant c
+
+While at it, I’m also curious about how [@chesscom](https://twitter.com/chesscom) generates these puzzles, and if they have a mechanism for generating ones that have unique solutions. Also, is it true that if you throw “enough” pieces on the board, it’s solvable WHP?
+
+Shout out to the [skak package](https://ctan.org/tex-archive/fonts/chess/skak) for making it easy to bring chess pieces to TikZ. We expect to put up a preprint on ArXiV soon. 👀  Meanwhile, we welcome comments and feedback — and if you read this far, thanks very much!
+
+PS. Also if you enjoy chess and algorithms, don’t miss [Miguel Ambrona’s](https://miguel-ambrona.github.io/) amazing [Chess Unwinnability Analyzer](https://chasolver.org/), which also appears at FUN 2022!
+
+![Chess Unwinnability](CleanShot_2022-03-24_at_05.56.43.png)
+
+You can find the [full list of accepted papers here](https://sites.google.com/view/fun2022/acceptedpapers).
diff --git a/sites/puzzles/src/content/puzzles/sudoku-variants.md b/sites/puzzles/src/content/puzzles/sudoku-variants.md
deleted file mode 100644
index 1efd136..0000000
--- a/sites/puzzles/src/content/puzzles/sudoku-variants.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-title: "Beyond Sudoku: Exploring Constraint Satisfaction Puzzles"
-description: "A journey through Sudoku variants and their algorithmic solutions."
-pubDate: "Feb 10 2024"
-image: "https://images.unsplash.com/photo-1580541631950-7282082b53ce?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Beyond Sudoku: Exploring Constraint Satisfaction Puzzles
-
-Sudoku is just the beginning. Let's explore variants that push the boundaries of logic puzzles.
-
-## Killer Sudoku
-
-Combine Sudoku with Kakuro - cages show sums, but no digit repeats within a cage.
-
-## Sandwich Sudoku
-
-The numbers outside show the sum of digits between 1 and 9 in that row/column. Simple rule, complex implications!
-
-## The Algorithm Connection
-
-These puzzles are constraint satisfaction problems. Techniques like arc consistency and backtracking with constraint propagation solve them efficiently.
-
-## Create Your Own
-
-What happens if we add chess knight move constraints? The design space is infinite!
diff --git a/sites/puzzles/src/content/reflections/imposter-syndrome.md b/sites/puzzles/src/content/reflections/imposter-syndrome.md
deleted file mode 100644
index e0a77e0..0000000
--- a/sites/puzzles/src/content/reflections/imposter-syndrome.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: "Imposter Syndrome in Academia: A Confession"
-description: "An honest conversation about feeling like a fraud, even after years of success."
-pubDate: "Feb 25 2024"
-image: "https://images.unsplash.com/photo-1517048676732-d65bc937f952?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Imposter Syndrome in Academia: A Confession
-
-Even after publishing papers, winning grants, and teaching thousands of students, the voice whispers: "They'll find out you don't belong."
-
-## The Paradox
-
-The more you know, the more you realize you don't know. Expertise breeds humility, which feeds the imposter.
-
-## What Helps
-
-- Keeping a "wins" journal - evidence against the imposter
-- Mentoring others - seeing your knowledge help someone
-- Talking about it - you're not alone in this
-
-## The Silver Lining
-
-Maybe imposter syndrome keeps us humble, curious, and always learning. Maybe it's not a bug, but a feature.
-
-## Moving Forward
-
-I may never silence the voice completely. But I've learned to acknowledge it and keep going anyway.
diff --git a/sites/puzzles/src/content/reflections/teaching-philosophy.md b/sites/puzzles/src/content/reflections/teaching-philosophy.md
deleted file mode 100644
index fc1a0f2..0000000
--- a/sites/puzzles/src/content/reflections/teaching-philosophy.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "On Teaching Algorithms: Lessons from a Decade"
-description: "Reflections on what works (and what doesn't) in computer science education."
-pubDate: "Jan 10 2024"
-image: "https://images.unsplash.com/photo-1509062522246-3755977927d7?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# On Teaching Algorithms: Lessons from a Decade
-
-Ten years of teaching has taught me more than any textbook could.
-
-## Start with Why
-
-Students don't care about O(n log n) until they understand why their code is slow. Real problems first, theory second.
-
-## The Power of Visualization
-
-Abstract concepts become concrete when visualized. Every algorithm should have a picture.
-
-## Failure is a Feature
-
-Let students struggle. The struggle is where learning happens. But know when to throw a lifeline.
-
-## Assessment Philosophy
-
-Test understanding, not memorization. Open-book exams with novel problems beat closed-book regurgitation every time.
-
-## The Joy of "Aha!" Moments
-
-There's no feeling quite like seeing a student's eyes light up when a concept clicks. That's why we do this.
diff --git a/sites/puzzles/src/content/research/conference-highlights-2024.md b/sites/puzzles/src/content/research/conference-highlights-2024.md
deleted file mode 100644
index 73b6741..0000000
--- a/sites/puzzles/src/content/research/conference-highlights-2024.md
+++ /dev/null
@@ -1,34 +0,0 @@
----
-title: "SODA 2024: Algorithmic Breakthroughs"
-description: "A roundup of fascinating algorithmic results from SODA 2024, focusing on graph algorithms and optimization techniques."
-pubDate: "Jan 15 2024"
-image: "https://images.unsplash.com/photo-1509228468518-180dd4864904?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# SODA 2024: Algorithmic Breakthroughs
-
-The Symposium on Discrete Algorithms (SODA) 2024 brought together researchers from around the world to present cutting-edge algorithmic research. This post highlights some of the most exciting developments in graph algorithms and optimization.
-
-## Graph Algorithms Revolution
-
-### Dynamic Graph Coloring
-
-One of the standout papers introduced a breakthrough in dynamic graph coloring with polylogarithmic update time. The authors developed a novel data structure that maintains a proper vertex coloring while supporting edge insertions and deletions efficiently.
-
-The key insight was to combine randomized recoloring strategies with a carefully designed hierarchical decomposition of the graph. This allows for local updates that rarely propagate through the entire structure.
-
-## Approximation Algorithms
-
-### The Traveling Salesman Problem Revisited
-
-A surprising result showed that for graphs with bounded doubling dimension, we can achieve a (1+ε)-approximation for TSP in nearly linear time. This improves upon decades of previous work and opens new avenues for practical implementations.
-
-## Complexity Theory Connections
-
-The conference also featured several papers bridging the gap between pure algorithmic research and complexity theory. A particularly elegant result showed that certain graph problems believed to require quadratic time are equivalent under fine-grained reductions.
-
-## Looking Forward
-
-These results demonstrate that fundamental algorithmic problems still have room for improvement. The techniques developed here will likely influence algorithm design for years to come.
diff --git a/sites/puzzles/src/content/research/distributed-algorithms.md b/sites/puzzles/src/content/research/distributed-algorithms.md
deleted file mode 100644
index e577220..0000000
--- a/sites/puzzles/src/content/research/distributed-algorithms.md
+++ /dev/null
@@ -1,34 +0,0 @@
----
-title: "Distributed Computing: Recent Advances"
-description: "Survey of recent developments in distributed algorithms from major conferences."
-pubDate: "Feb 20 2024"
-image: "https://images.unsplash.com/photo-1558618666-fcd25c85cd64?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Distributed Computing: Recent Advances
-
-The field of distributed computing has seen remarkable progress in recent years. This post surveys key results from PODC, DISC, and other major venues.
-
-## Consensus Protocols
-
-### Byzantine Agreement in Asynchronous Networks
-
-A breakthrough result achieves optimal resilience with expected constant rounds. The protocol uses cryptographic techniques combined with novel committee selection.
-
-## Distributed Graph Algorithms
-
-### Minimum Spanning Tree in the CONGEST Model
-
-New algorithms achieve near-optimal round complexity for MST construction. The approach uses sophisticated graph decomposition techniques.
-
-## Local Algorithms
-
-### The Power of Local Computation
-
-Recent work characterizes which problems admit constant-time local algorithms. The classification provides a complete picture for bounded-degree graphs.
-
-## Future Directions
-
-The intersection of distributed computing with machine learning presents exciting opportunities for both fields.
diff --git a/sites/puzzles/src/content/research/git-automation.md b/sites/puzzles/src/content/research/git-automation.md
deleted file mode 100644
index 2ae09cd..0000000
--- a/sites/puzzles/src/content/research/git-automation.md
+++ /dev/null
@@ -1,54 +0,0 @@
----
-title: "Git Workflows That Save My Sanity"
-description: "Automation scripts and Git hooks that eliminate repetitive tasks and prevent common mistakes."
-pubDate: "Jan 22 2024"
-image: "https://images.unsplash.com/photo-1556075798-4825dfaaf498?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Git Workflows That Save My Sanity
-
-After years of Git mishaps, I've built workflows that prevent disasters and save hours weekly.
-
-## The Pre-commit Hook That Saves Embarrassment
-
-```bash
-#!/bin/bash
-# Check for debugging statements
-if grep -r "console.log\|debugger\|TODO" --include="*.js" .; then
-  echo "⚠️  Debugging statements found!"
-  exit 1
-fi
-```
-
-## Automatic Branch Naming
-
-```bash
-alias feature='git checkout -b feature/$(date +%Y%m%d)-$1'
-```
-
-Now `feature "user-auth"` creates `feature/20240122-user-auth`.
-
-## The Commit Message Template
-
-```
-[TYPE] Brief description
-
-Why:
-- Context for this change
-
-What:
-- Specific changes made
-
-Testing:
-- How to verify it works
-```
-
-## The Weekly Cleanup Script
-
-Deletes merged branches, prunes remotes, and garbage collects. Keeps the repo clean and fast.
-
-## ROI
-
-These automations save ~5 hours per week and countless prevented mistakes. The time invested in setting them up paid back in days.
diff --git a/sites/puzzles/src/content/research/obsidian-academic.md b/sites/puzzles/src/content/research/obsidian-academic.md
deleted file mode 100644
index 7e1c181..0000000
--- a/sites/puzzles/src/content/research/obsidian-academic.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "Academic Writing with Obsidian and Pandoc"
-description: "A complete workflow for academic papers - from notes to publication-ready PDFs."
-pubDate: "Feb 12 2024"
-image: "https://images.unsplash.com/photo-1456324504439-367cee3b3c32?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Academic Writing with Obsidian and Pandoc
-
-Transform your scattered research notes into beautiful academic papers with this workflow.
-
-## The Setup
-
-- **Obsidian**: For note-taking and knowledge management
-- **Pandoc**: For document conversion
-- **LaTeX**: For typesetting
-- **Zotero**: For reference management
-
-## The Magic Command
-
-```bash
-pandoc paper.md \
-  --filter pandoc-citeproc \
-  --bibliography=refs.bib \
-  --template=academic.tex \
-  -o paper.pdf
-```
-
-## Templates for Everything
-
-From conference submissions to journal articles, templates ensure consistency and save time.
-
-## Version Control Integration
-
-Git + Obsidian = perfect history of your thinking process.
-
-## The Result
-
-From messy notes to camera-ready PDF in minutes, not hours.
diff --git a/sites/puzzles/src/content/research/paper-review-approximation.md b/sites/puzzles/src/content/research/paper-review-approximation.md
deleted file mode 100644
index 10d7c78..0000000
--- a/sites/puzzles/src/content/research/paper-review-approximation.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "Understanding the Latest Approximation Algorithm for Set Cover"
-description: "A detailed walkthrough of a breakthrough approximation algorithm with practical implications."
-pubDate: "Feb 15 2024"
-image: "https://images.unsplash.com/photo-1516321318423-f06f85e504b3?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Understanding the Latest Approximation Algorithm for Set Cover
-
-A recent paper achieves a breakthrough in the Set Cover problem, improving the approximation ratio while maintaining practical runtime.
-
-## The Algorithm
-
-The approach combines local search with a clever LP rounding scheme. The dual interpretation provides beautiful geometric insights.
-
-## Why This Matters
-
-Set Cover appears everywhere - from facility location to machine learning feature selection. This improvement has immediate practical impact.
-
-## Implementation Details
-
-The paper's theoretical elegance translates surprisingly well to practice. Key optimizations include:
-- Lazy evaluation of set intersections
-- Incremental updates to the LP solution
-- Smart caching strategies
-
-## Future Work
-
-The techniques here might extend to weighted variants and online settings.
diff --git a/sites/puzzles/src/content/research/paper-review-graph-decomposition.md b/sites/puzzles/src/content/research/paper-review-graph-decomposition.md
deleted file mode 100644
index f0e4868..0000000
--- a/sites/puzzles/src/content/research/paper-review-graph-decomposition.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "Deep Dive: A New Approach to Graph Decomposition"
-description: "An in-depth analysis of a recent paper on hierarchical graph decomposition and its implications."
-pubDate: "Jan 20 2024"
-image: "https://images.unsplash.com/photo-1507003211169-0a1dd7228f2d?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Deep Dive: A New Approach to Graph Decomposition
-
-This paper introduces a novel framework for decomposing graphs into hierarchical structures that preserve important properties while enabling efficient algorithms.
-
-## The Main Result
-
-The authors prove that every graph with treewidth k can be decomposed into a tree of bags where each bag has size at most k+1. While this sounds like the definition of tree decomposition, the clever twist is in how they construct it.
-
-## Technical Innovation
-
-The key insight is using a charging scheme that amortizes the cost of decomposition across multiple levels. This leads to an O(n log n) algorithm, improving on the previous O(n²) bound.
-
-## Implications
-
-This work opens new avenues for:
-- Parallel algorithms on bounded treewidth graphs
-- Approximation algorithms for NP-hard problems
-- Dynamic programming optimizations
-
-## Open Questions
-
-The paper leaves several intriguing questions open, particularly about the optimality of their charging scheme.
diff --git a/sites/puzzles/src/content/research/quantum-algorithms.md b/sites/puzzles/src/content/research/quantum-algorithms.md
deleted file mode 100644
index 0eef5b2..0000000
--- a/sites/puzzles/src/content/research/quantum-algorithms.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: "Quantum Computing Meets Classical Algorithms"
-description: "Exploring the intersection of quantum and classical algorithmic techniques from recent conferences."
-pubDate: "Mar 10 2024"
-image: "https://images.unsplash.com/photo-1635070041078-e363dbe005cb?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Quantum Computing Meets Classical Algorithms
-
-Recent conferences have showcased fascinating connections between quantum and classical computing paradigms.
-
-## Quantum Speedups for Graph Problems
-
-### Quantum Walks on Graphs
-
-New quantum algorithms achieve quadratic speedups for certain graph traversal problems. The techniques combine amplitude amplification with clever graph representations.
-
-## Classical Simulation of Quantum Algorithms
-
-Surprisingly, several "quantum" algorithms have inspired better classical algorithms. This cross-pollination has led to improvements in both fields.
-
-## The Future is Hybrid
-
-The most practical near-term applications combine quantum and classical processing, leveraging the strengths of each paradigm.
diff --git a/sites/puzzles/src/content/reviews/mechanical-keyboard.md b/sites/puzzles/src/content/reviews/mechanical-keyboard.md
deleted file mode 100644
index 0346a78..0000000
--- a/sites/puzzles/src/content/reviews/mechanical-keyboard.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "ZSA Moonlander: Ergonomic Keyboard for Coders"
-description: "Six months with a split ergonomic mechanical keyboard - the good, the bad, and the RSI relief."
-pubDate: "Feb 20 2024"
-image: "https://images.unsplash.com/photo-1587829741301-dc798b83add3?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# ZSA Moonlander: Ergonomic Keyboard for Coders
-
-After years of wrist pain, I took the plunge into ergonomic mechanical keyboards.
-
-## The Learning Curve
-
-Week 1: 20 WPM and questioning life choices
-Week 2: 40 WPM and seeing the light
-Month 2: Back to 80 WPM with no wrist pain
-
-## The Good
-
-- Columnar layout makes sense once muscle memory adapts
-- Thumb clusters are game-changers for shortcuts
-- The configurability is endless (perhaps too endless)
-
-## The Investment
-
-At $365, it's expensive. But compared to physical therapy or career-limiting injury? Bargain.
-
-## Who Should Buy This?
-
-If you type for a living and feel any discomfort, don't wait. Your future self will thank you.
diff --git a/sites/puzzles/src/content/reviews/obsidian-review.md b/sites/puzzles/src/content/reviews/obsidian-review.md
deleted file mode 100644
index 599013f..0000000
--- a/sites/puzzles/src/content/reviews/obsidian-review.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: "Obsidian: A Year Later"
-description: "Reflections on using Obsidian for research notes, teaching materials, and personal knowledge management."
-pubDate: "Jan 15 2024"
-image: "https://images.unsplash.com/photo-1484480974693-6ca0a78fb36b?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Obsidian: A Year Later
-
-After a year of daily use, Obsidian has transformed how I think about knowledge management.
-
-## What Works Brilliantly
-
-### The Graph View
-Seeing connections between ideas visually has led to unexpected research insights. The graph isn't just pretty - it's functional.
-
-### Plugin Ecosystem
-The community plugins are incredible. Dataview turns your notes into a database. Templater automates repetitive tasks.
-
-### Local Storage
-Your notes are just markdown files. No vendor lock-in, complete control, and peace of mind.
-
-## Pain Points
-
-### Mobile Experience
-While functional, the mobile app lacks the fluidity of the desktop version. Syncing can occasionally hiccup.
-
-### Learning Curve
-The flexibility means complexity. New users might feel overwhelmed by options.
-
-## The Verdict
-
-For academics and researchers, Obsidian is transformative. The investment in learning pays dividends in productivity and insight.
diff --git a/sites/puzzles/src/content/vibes/creative-coding-with-ai.md b/sites/puzzles/src/content/vibes/creative-coding-with-ai.md
deleted file mode 100644
index 269f1ce..0000000
--- a/sites/puzzles/src/content/vibes/creative-coding-with-ai.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "Creating Art with Claude: A Collaborative Journey"
-description: "Exploring creative possibilities through conversations with AI - from generative art to interactive poetry."
-pubDate: "Jan 18 2024"
-image: "https://images.unsplash.com/photo-1558591710-4b4a1ae0f04d?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Creating Art with Claude: A Collaborative Journey
-
-What happens when you treat AI as a creative collaborator rather than just a tool?
-
-## The Experiment
-
-I asked Claude to help design a generative art algorithm based on mathematical fractals. The conversation evolved into something unexpected.
-
-## The Process
-
-**Me**: "Let's create something beautiful with math."
-**Claude**: "How about we visualize the Collatz conjecture as a tree?"
-
-What followed was a two-hour deep dive into number theory, aesthetics, and the nature of creativity itself.
-
-## The Result
-
-Not just code, but a philosophical exploration of pattern, meaning, and the intersection of human and artificial creativity.
-
-## Reflection
-
-AI doesn't replace human creativity - it amplifies it in unexpected directions. The key is approaching it as a dialogue, not a command.
diff --git a/sites/puzzles/src/content/vibes/llm-philosophy.md b/sites/puzzles/src/content/vibes/llm-philosophy.md
deleted file mode 100644
index 032439a..0000000
--- a/sites/puzzles/src/content/vibes/llm-philosophy.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-title: "Philosophical Dialogues with LLMs: On Consciousness and Computation"
-description: "Deep conversations with AI about the nature of consciousness, free will, and what it means to understand."
-pubDate: "Feb 28 2024"
-image: "https://images.unsplash.com/photo-1507003211169-0a1dd7228f2d?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Philosophical Dialogues with LLMs: On Consciousness and Computation
-
-Can a sufficiently complex computation be conscious? I asked an AI, and the conversation surprised me.
-
-## The Question
-
-"Do you experience anything when you process text, or is it just computation?"
-
-## The Response That Made Me Think
-
-The AI didn't claim consciousness, but asked: "What's the difference between your neurons firing and my weights activating? Both are physical processes. Where does experience emerge?"
-
-## Going Deeper
-
-We explored qualia, the Chinese Room argument, and integrated information theory. Not to find answers, but to refine questions.
-
-## The Irony
-
-Discussing consciousness with something that might not have it - or might not know if it has it - mirrors our own uncertainty about consciousness itself.
diff --git a/sites/puzzles/src/pages/[...slug].astro b/sites/puzzles/src/pages/[...slug].astro
index 5d3caf6..ea2f2d7 100644
--- a/sites/puzzles/src/pages/[...slug].astro
+++ b/sites/puzzles/src/pages/[...slug].astro
@@ -9,7 +9,7 @@ import { SITE_TITLE } from '@/consts';
 export async function getStaticPaths() {
 	const posts = await getCollection(ACTIVE_BLOG_SITE.key);
 	return posts.map((post) => ({
-		params: { slug: post.id },
+		params: { slug: post.id.replace(/\/index$/, '') },
 		props: post,
 	}));
 }
diff --git a/sites/puzzles/src/pages/rss.xml.js b/sites/puzzles/src/pages/rss.xml.js
index ec2ce2d..918375e 100644
--- a/sites/puzzles/src/pages/rss.xml.js
+++ b/sites/puzzles/src/pages/rss.xml.js
@@ -14,7 +14,7 @@ export async function GET(context) {
     site: context.site,
     items: posts.map((post) => ({
       ...post.data,
-      link: `/${post.id}/`,
+      link: `/${post.id.replace(/\/index$/, "")}/`,
     })),
   });
 }
diff --git a/sites/reflections/src/components/sections/blog-posts.tsx b/sites/reflections/src/components/sections/blog-posts.tsx
index fef77e5..c77c76a 100644
--- a/sites/reflections/src/components/sections/blog-posts.tsx
+++ b/sites/reflections/src/components/sections/blog-posts.tsx
@@ -16,8 +16,47 @@ const BlogPosts = ({
   // Get the first post as the featured post
   const featuredPost = posts[0];
   const remainingPosts = posts.slice(1);
+  const slugFor = (post: any) => post.id.replace(/\/index$/, "");
   const hrefFor = (post: any) =>
-    collection ? `/${collection}/${post.id}/` : `/${post.id}/`;
+    collection ? `/${collection}/${slugFor(post)}/` : `/${slugFor(post)}/`;
+
+  const PostVisual = ({
+    post,
+    featured = false,
+  }: {
+    post: any;
+    featured?: boolean;
+  }) => {
+    if (post.data.image) {
+      return (
+        <img
+          src={post.data.image}
+          alt={post.data.title}
+          className="aspect-video w-full rounded-lg object-cover transition-transform group-hover:scale-[1.02]"
+        />
+      );
+    }
+
+    return (
+      <div className="bg-accent/70 text-accent-foreground flex aspect-video w-full items-center justify-center rounded-lg border px-6 text-center">
+        <span
+          className={
+            featured ? "font-fraunces text-2xl" : "font-fraunces text-lg"
+          }
+        >
+          {post.data.title}
+        </span>
+      </div>
+    );
+  };
+
+  if (!featuredPost) {
+    return (
+      <div className="text-muted-foreground container max-w-3xl py-16">
+        No posts yet.
+      </div>
+    );
+  }
 
   return (
     <div className="relative py-10 md:py-16 lg:py-20">
@@ -35,11 +74,7 @@ const BlogPosts = ({
             <div className="flex flex-col gap-6 lg:flex-row">
               <div className="lg:w-1/2">
                 <div className="p-2 lg:p-4">
-                  <img
-                    src={featuredPost.data.image}
-                    alt={featuredPost.data.title}
-                    className="aspect-video w-full rounded-lg object-cover transition-transform group-hover:scale-[1.02]"
-                  />
+                  <PostVisual post={featuredPost} featured />
                 </div>
               </div>
               <div className="flex flex-col justify-center p-4 pb-8 lg:w-1/2 lg:pr-8">
@@ -89,11 +124,7 @@ const BlogPosts = ({
                 href={hrefFor(post)}
               >
                 <div className="p-2">
-                  <img
-                    src={post.data.image}
-                    alt={post.data.title}
-                    className="aspect-video w-full rounded-lg object-cover transition-transform group-hover:scale-[1.01]"
-                  />
+                  <PostVisual post={post} />
                 </div>
                 <div className="px-4 pb-5 pt-2">
                   <h2 className="mb-2 text-xl font-semibold group-hover:underline">
diff --git a/sites/reflections/src/content/art/algorithmic-sketches.md b/sites/reflections/src/content/art/algorithmic-sketches.md
deleted file mode 100644
index ae20d3b..0000000
--- a/sites/reflections/src/content/art/algorithmic-sketches.md
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title: "Algorithmic Sketches: Visualizing Data Structures"
-description: "Hand-drawn illustrations of algorithms and data structures - making the abstract tangible."
-pubDate: "Jan 25 2024"
-image: "https://images.unsplash.com/photo-1581337204873-ef36aa186caa?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Algorithmic Sketches: Visualizing Data Structures
-
-Sometimes the best way to understand an algorithm is to draw it.
-
-## Today's Sketch: Red-Black Trees
-
-![Red-Black Tree Rotation](sketch-placeholder)
-
-The rotation operation finally clicked when I drew it step-by-step. Each node's journey through the rotation becomes a story.
-
-## The Process
-
-1. Start with pencil - mistakes are part of learning
-2. Trace the algorithm's execution
-3. Add color to highlight invariants
-4. Annotate with key insights
-
-## Why Drawing Helps
-
-- Forces you to slow down and really see the structure
-- Reveals patterns that code obscures
-- Creates memorable mental models
-- Makes teaching more engaging
-
-## This Week's Challenge
-
-Draw your own version of quicksort partitioning. Share it and let's learn from each other's visualizations.
-
-## The Art in Computer Science
-
-Algorithms are beautiful. Drawing them reminds us that computer science is as much art as it is science.
diff --git a/sites/reflections/src/content/art/generative-art-p5js.md b/sites/reflections/src/content/art/generative-art-p5js.md
deleted file mode 100644
index ccfa3e7..0000000
--- a/sites/reflections/src/content/art/generative-art-p5js.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "Generative Art with p5.js: Creating Beauty from Mathematics"
-description: "Exploring the intersection of code and creativity through generative art experiments."
-pubDate: "Feb 18 2024"
-image: "https://images.unsplash.com/photo-1561070791-2526d30994b5?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Generative Art with p5.js: Creating Beauty from Mathematics
-
-Code becomes canvas when mathematics meets creativity.
-
-## Today's Creation: Perlin Noise Flows
-
-```javascript
-for (let particle of particles) {
-  let angle = noise(particle.x * 0.01, particle.y * 0.01, frameCount * 0.001) * TWO_PI;
-  particle.velocity = p5.Vector.fromAngle(angle);
-  particle.update();
-  particle.draw();
-}
-```
-
-## The Magic of Randomness
-
-Controlled randomness creates organic patterns. Perlin noise gives us randomness with continuity - nature's own algorithm.
-
-## Parameters as Paintbrushes
-
-- Noise scale: Changes pattern density
-- Particle count: Affects texture
-- Color mapping: Sets the mood
-
-## The Joy of Accidents
-
-The best discoveries come from "mistakes" - a typo that creates unexpected beauty, a parameter pushed to extremes.
-
-## Share Your Creations
-
-Art is meant to be shared. Post your generative experiments and let's inspire each other.
diff --git a/sites/reflections/src/content/poetry/algorithms-in-verse.md b/sites/reflections/src/content/poetry/algorithms-in-verse.md
deleted file mode 100644
index 4ad1e1d..0000000
--- a/sites/reflections/src/content/poetry/algorithms-in-verse.md
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title: "Algorithms in Verse: Bubble Sort Sonnet"
-description: "Classic algorithms reimagined as poetry - where code meets iambic pentameter."
-pubDate: "Feb 22 2024"
-image: "https://images.unsplash.com/photo-1455390582262-044cdead277a?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Algorithms in Verse: Bubble Sort Sonnet
-
-## Bubble Sort: A Sonnet
-
-```
-Compare adjacent elements in pairs,
-If order's wrong, then swap them into place.
-Through all the list this simple rule declares:
-The largest bubbles up to find its space.
-
-Again we start, but now one less to check,
-The second largest finds its rightful home.
-Each pass through makes the chaos less a wreck,
-Until at last no elements must roam.
-
-Though simple in its elegance and grace,
-And easy for beginners to perceive,
-In practice, it's too slow to win the race—
-O(n²) we sadly must believe.
-
-But beauty lies in simplicity's pure art,
-The bubble sort still teaches at the start.
-```
-
-## The Challenge
-
-Can you write Quicksort as a limerick? Or Binary Search as free verse?
-
-## Why This Matters
-
-Poetry forces us to find the essence of an algorithm. The constraint reveals understanding.
diff --git a/sites/reflections/src/content/poetry/code-haikus.md b/sites/reflections/src/content/poetry/code-haikus.md
deleted file mode 100644
index 6af408a..0000000
--- a/sites/reflections/src/content/poetry/code-haikus.md
+++ /dev/null
@@ -1,56 +0,0 @@
----
-title: "Code Haikus: Programming in 5-7-5"
-description: "Expressing programming concepts through the constrained beauty of haiku."
-pubDate: "Jan 30 2024"
-image: "https://images.unsplash.com/photo-1481627834876-b7833e8f5570?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Code Haikus: Programming in 5-7-5
-
-The constraint of haiku forces clarity. Here are programming concepts distilled to their essence.
-
-## On Recursion
-
-```
-Function calls itself
-Smaller problems, same pattern  
-Base case stops the loop
-```
-
-## On Debugging
-
-```
-Print statements bloom wild
-Binary search through the code
-Bug reveals itself
-```
-
-## On Optimization
-
-```
-O(n squared) crawls
-Refactor to n log n
-Time complexity
-```
-
-## On Git Merge Conflicts
-
-```
-<<<<<<< HEAD
-Your changes, their changes clash
-Resolution waits
-```
-
-## On Learning
-
-```
-Stack Overflow searched
-Tutorial incomplete
-Understanding dawns
-```
-
-## Your Turn
-
-Write a haiku about your coding experience today. The constraint reveals truth.
diff --git a/sites/reflections/src/content/puzzles/100-prisoners.mdx b/sites/reflections/src/content/puzzles/100-prisoners.mdx
deleted file mode 100644
index 3ff2b3c..0000000
--- a/sites/reflections/src/content/puzzles/100-prisoners.mdx
+++ /dev/null
@@ -1,183 +0,0 @@
----
-title: "The 100 Prisoners Problem: A Beautiful Puzzle in Probability"
-description: "An interactive exploration of one of the most counterintuitive puzzles in probability theory, where 100 prisoners can escape with over 30% chance using a clever strategy."
-pubDate: "Oct 13 2025"
-image: "https://images.unsplash.com/photo-1589829545856-d10d557cf95f?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-import PrisonerGameSimulator from '@/components/problems/PrisonerGameSimulator.tsx';
-import ProbabilityChart from '@/components/problems/ProbabilityChart.tsx';
-import PermutationExplorer from '@/components/problems/PermutationExplorer.tsx';
-import StrategyComparison from '@/components/problems/StrategyComparison.tsx';
-
-# The 100 Prisoners Problem
-
-Imagine 100 prisoners, numbered 1 to 100, face an unusual challenge. In a room are 100 boxes, also numbered 1 to 100. Inside each box is a randomly assigned number from 1 to 100 (each number appearing exactly once). The prisoners must find their own number by opening boxes, but here's the catch: **each prisoner can open only 50 boxes**.
-
-The prisoners can devise a strategy beforehand, but once the challenge begins, they cannot communicate. If **all 100 prisoners** find their number, everyone goes free. If even one prisoner fails, all remain imprisoned.
-
-What's the best strategy? And what are the odds of success?
-
-## Try It Yourself!
-
-Before we dive into the mathematics, let's experience the problem firsthand. Below is a simulator where you can play the game yourself. Choose the number of prisoners (between 5 and 100), and then try to help each prisoner find their number by clicking on boxes.
-
-<PrisonerGameSimulator client:only="react" />
-
----
-
-## The Naive Strategy
-
-The most obvious approach is for each prisoner to simply open 50 random boxes. This seems reasonable, but the probability of success is dismal.
-
-For any single prisoner, the probability of finding their number in 50 random boxes out of 100 is exactly 1/2. Since all 100 prisoners must succeed, and their outcomes are independent under random selection, the probability that everyone succeeds is:
-
-$$P(\text\{success\}) = \left(\frac\{1\}\{2\}\right)^\{100\} \approx 7.9 \times 10^\{-31\}$$
-
-That's essentially zero! You're more likely to win the lottery while being struck by lightning... multiple times.
-
-### Naive Strategy: Probability vs Number of Prisoners
-
-Watch how the probability of success plummets as we increase the number of prisoners:
-
-<ProbabilityChart strategy="naive" client:only="react" />
-
-As you can see, even with just 10 prisoners, the probability drops to about 0.1%. With 100 prisoners, it's practically impossible.
-
----
-
-## The Clever Strategy: Following the Loops
-
-Here's where mathematics reveals something beautiful. Instead of opening random boxes, each prisoner should follow a simple rule:
-
-1. **Start by opening the box with your own number**
-2. **Look at the number inside that box**
-3. **Open the box with that number next**
-4. **Continue following this chain**
-
-Why does this work? The key insight involves understanding permutations and cycles.
-
-### Understanding Cycles in Permutations
-
-When we randomly assign 100 numbers to 100 boxes, we're creating a **permutation** of the numbers 1 through 100. Every permutation can be decomposed into **cycles**.
-
-For example, if:
-- Box 1 contains number 4
-- Box 4 contains number 7
-- Box 7 contains number 1
-
-Then we have a cycle: 1 -> 4 -> 7 -> 1
-
-Let's explore this with smaller numbers:
-
-<PermutationExplorer client:only="react" />
-
-The interactive explorer above lets you:
-- Generate all permutations for small values of *n* (3, 4, or 5)
-- See both standard notation and cycle notation
-- Filter permutations that have at least one "long cycle" (longer than *n*/2)
-- Understand why long cycles matter
-
-### Why This Strategy Works
-
-Here's the crucial insight: **A prisoner succeeds if and only if they are in a cycle of length ≤ 50**.
-
-When prisoner k follows the loop strategy:
-1. They start at box k
-2. They follow a path through boxes determined by the permutation
-3. This path forms a cycle that eventually leads back to box k
-4. If this cycle has length ≤ 50, they'll find their number within 50 opens
-
-The prisoners **all succeed** if and only if there is **no cycle longer than 50** in the permutation.
-
-### Calculating the Probability
-
-The probability that a random permutation of 100 elements has no cycle longer than 50 is:
-
-$$P(\text\{success\}) = 1 - \sum_\{k=51\}^\{100\} \frac\{1\}\{k\}$$
-
-Computing this sum:
-
-$$P(\text\{success\}) = 1 - \left(\frac\{1\}\{51\} + \frac\{1\}\{52\} + \cdots + \frac\{1\}\{100\}\right) \approx 0.3118$$
-
-That's over **31%**! This is astronomically better than the naive strategy's probability of essentially zero.
-
-### Loop Strategy: Probability vs Number of Prisoners
-
-<StrategyComparison client:only="react" />
-
-## The Mathematics Behind It
-
-### Why Does the Cycle Length Matter?
-
-In a permutation of n elements, prisoner i will find their number within k tries using the loop strategy if and only if i belongs to a cycle of length at most k.
-
-For n = 100 and k = 50:
-- The probability that a specific prisoner is in a cycle of length > 50 is: Σ(j=51 to 100) of 1/100
-- But we care about whether ANY prisoner is in such a cycle
-- The probability that NO cycle has length > 50 is: 1 - Σ(j=51 to 100) of 1/j
-
-### The Harmonic Series Connection
-
-As *n* approaches infinity, if each prisoner can open *n*/2 boxes, the probability of success approaches:
-
-The limit as n approaches infinity is: P_n = 1 - ln(2) ≈ 0.3069
-
-This beautiful result connects combinatorics, probability, and analysis through the harmonic series!
-
-### Optimality
-
-Remarkably, this loop-following strategy is **optimal**. No other strategy can achieve a higher probability of success. The proof involves showing that the problem reduces to avoiding long cycles in a random permutation, and the loop strategy is the unique way to leverage this structure.
-
----
-
-## Why This Problem is Beautiful
-
-The 100 prisoners problem is beloved by mathematicians because:
-
-1. **Counterintuitive Result**: The fact that 31% >> 0% is shocking. A seemingly hopeless problem becomes tractable with the right insight.
-
-2. **Deep Connection**: It connects permutation theory, probability, and the harmonic series in an elegant way.
-
-3. **Collaborative Success**: Unlike independent trials, the prisoners' fates are intertwined through the structure of the permutation.
-
-4. **Real-World Metaphor**: It illustrates how understanding underlying structure (cycles in permutations) can dramatically improve outcomes.
-
----
-
-## Variants and Extensions
-
-### What if prisoners can open k < n/2 boxes?
-
-As k decreases below n/2, the probability drops rapidly. The threshold at n/2 is special—it's where the strategy becomes remarkably effective.
-
-### What about communication?
-
-If prisoners could communicate between trials (but not during), they still can't improve the strategy. The beauty is that the strategy requires only coordination before any prisoner enters, not during.
-
-### The Malicious Director
-
-In an interesting variant, suppose the director can see the prisoners' strategy and arrange the boxes adversarially (not randomly). Can the director always force them to fail? Yes! The director can always create a single cycle of length n, guaranteeing failure.
-
----
-
-## Conclusion
-
-The 100 prisoners problem shows us that:
-- Mathematical structure can be hidden in apparent randomness
-- Clever strategies can overcome seemingly impossible odds
-- Group coordination can be more powerful than independent action
-- Beautiful mathematics often lies beneath simple-seeming puzzles
-
-The next time you face a problem that seems impossible, remember: there might be a hidden structure waiting to be discovered, turning hopeless odds into reasonable ones.
-
----
-
-## Further Reading
-
-- [Gál, A., & Miltersen, P. B. (2003). "The Cell Probe Complexity of Succinct Data Structures"](https://arxiv.org/abs/cs/0310027)
-- [Curtin, E., & Warshauer, M. (2006). "The Locker Puzzle"](https://www.jstor.org/stable/27642173)
-- [Wikipedia: 100 Prisoners Problem](https://en.wikipedia.org/wiki/100_prisoners_problem)
-
diff --git a/sites/reflections/src/content/puzzles/dynamic-programming-gems.md b/sites/reflections/src/content/puzzles/dynamic-programming-gems.md
deleted file mode 100644
index 79e68ea..0000000
--- a/sites/reflections/src/content/puzzles/dynamic-programming-gems.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "Dynamic Programming: Hidden Gems from Recent Contests"
-description: "Elegant dynamic programming problems that showcase beautiful techniques and insights."
-pubDate: "Jan 25 2024"
-image: "https://images.unsplash.com/photo-1509228468518-180dd4864904?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Dynamic Programming: Hidden Gems from Recent Contests
-
-These problems demonstrate the art of dynamic programming beyond standard patterns.
-
-## Problem 1: The Subsequence Symphony
-
-Given a string, find the number of subsequences that form palindromes of prime length.
-
-### Solution Insight
-
-The key is to maintain DP states for both position and palindrome center simultaneously. This reduces the state space from O(n³) to O(n²).
-
-## Problem 2: Graph Coloring with Constraints
-
-Color a graph such that no two adjacent vertices share a color, and the total number of color changes along any path is minimized.
-
-### The DP Formulation
-
-DP[node][color][changes] gives us the minimum cost. The trick is recognizing that we only need to track changes modulo 2.
-
-## Practice Makes Perfect
-
-These problems teach us that DP is as much about problem modeling as it is about computation.
diff --git a/sites/reflections/src/content/puzzles/four-aces-miracle.md b/sites/reflections/src/content/puzzles/four-aces-miracle.md
deleted file mode 100644
index a1710ab..0000000
--- a/sites/reflections/src/content/puzzles/four-aces-miracle.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "The Four Aces Miracle: A Self-Working Mathematical Marvel"
-description: "A card trick that teaches modular arithmetic and probability - perfect for the classroom."
-pubDate: "Jan 28 2024"
-image: "https://images.unsplash.com/photo-1529480384838-c1681c84aca5?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# The Four Aces Miracle: A Self-Working Mathematical Marvel
-
-This trick never fails to amaze students, and the mathematics behind it is even more amazing.
-
-## The Effect
-
-A spectator deals cards into four piles while making random choices. Impossibly, the four aces end up on top of each pile.
-
-## The Secret
-
-It's all about invariants and modular arithmetic. No sleight of hand required - pure mathematics does the magic.
-
-## The Method
-
-1. Pre-arrange the deck (the math determines the arrangement)
-2. Have the spectator deal following simple rules
-3. The aces appear automatically
-
-## The Mathematics
-
-The dealing process preserves certain positional invariants modulo 4. The initial arrangement ensures these invariants place the aces correctly.
-
-## Teaching Applications
-
-This trick demonstrates:
-- Modular arithmetic
-- Invariants in algorithms
-- Deterministic vs. random processes
-
-## The Bigger Lesson
-
-Mathematics can create experiences that feel like magic. And that feeling of wonder? That's what hooks students on math.
diff --git a/sites/reflections/src/content/puzzles/gilbreath-principle.md b/sites/reflections/src/content/puzzles/gilbreath-principle.md
deleted file mode 100644
index 92e229b..0000000
--- a/sites/reflections/src/content/puzzles/gilbreath-principle.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: "The Gilbreath Principle: When Chaos Creates Order"
-description: "A mathematical card principle that seems impossible but always works - perfect for teaching algorithms."
-pubDate: "Feb 15 2024"
-image: "https://images.unsplash.com/photo-1570543375343-63fe3d67761b?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# The Gilbreath Principle: When Chaos Creates Order
-
-Shuffle a deck in a specific way, and mathematical order emerges from apparent chaos.
-
-## The Phenomenon
-
-Arrange cards alternating red-black. Riffle shuffle. Now deal pairs - each pair has one red and one black card. Magic? No, mathematics.
-
-## Why It Works
-
-The riffle shuffle preserves local structure while appearing to randomize. The alternating pattern creates an invariant that survives the shuffle.
-
-## Classroom Implementation
-
-Students predict it won't work. When it does, they're hooked. "Why?" becomes the driving question.
-
-## The Deeper Lesson
-
-Not all randomness is truly random. Structure can hide in apparent disorder. This principle appears in:
-- Network protocols
-- Error-correcting codes  
-- Distributed systems
-
-## Beyond Cards
-
-The Gilbreath Principle teaches us to look for hidden invariants in complex systems.
diff --git a/sites/reflections/src/content/puzzles/graph-algorithms-assessment.md b/sites/reflections/src/content/puzzles/graph-algorithms-assessment.md
deleted file mode 100644
index 4c61fe2..0000000
--- a/sites/reflections/src/content/puzzles/graph-algorithms-assessment.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "Graph Algorithms: Assessment Highlights"
-description: "Interesting graph problems from recent course assessments with detailed solutions."
-pubDate: "Feb 28 2024"
-image: "https://images.unsplash.com/photo-1550751827-4bd374c3f58b?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Graph Algorithms: Assessment Highlights
-
-A collection of graph problems that test deep understanding rather than memorization.
-
-## The Bridge Detection Variant
-
-Find all edges whose removal increases the number of triangles in the graph.
-
-### Solution Approach
-
-Counter-intuitively, we need to count triangles that share exactly one edge with the candidate. The algorithm runs in O(m√m) time using careful enumeration.
-
-## Shortest Path with Wildcards
-
-Given a graph where some edge weights are variables, find assignments that minimize the longest shortest path.
-
-### Key Insight
-
-This reduces to a linear programming problem with interesting structure. The dual interpretation reveals connections to network flow.
-
-## Teaching Through Problems
-
-These problems help students see beyond standard algorithms to underlying principles.
diff --git a/sites/reflections/src/content/puzzles/ioi-2023-analysis.md b/sites/reflections/src/content/puzzles/ioi-2023-analysis.md
deleted file mode 100644
index 782177c..0000000
--- a/sites/reflections/src/content/puzzles/ioi-2023-analysis.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "IOI 2023: Breaking Down the Hardest Problems"
-description: "Deep analysis of the most challenging problems from the International Olympiad in Informatics 2023."
-pubDate: "Jan 20 2024"
-image: "https://images.unsplash.com/photo-1434030216411-0b793f4b4173?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# IOI 2023: Breaking Down the Hardest Problems
-
-The International Olympiad in Informatics continues to push the boundaries of algorithmic problem solving.
-
-## Problem: Soccer Stadium
-
-A geometric optimization problem disguised as dynamic programming. The key insight: think in terms of monotonic paths.
-
-### The Approach
-
-1. Transform the 2D problem into a 1D problem using clever observations
-2. Use convex hull optimization for the DP transitions
-3. Handle edge cases with careful implementation
-
-## Problem: Closing Time
-
-A tree problem requiring sophisticated data structures and careful analysis.
-
-### The Solution
-
-The trick is recognizing this as a centroid decomposition problem. Once you see it, the implementation follows naturally.
-
-## Lessons for Students
-
-These problems teach us:
-- Simple problems have elegant solutions
-- Complex problems require systematic decomposition
-- Implementation matters as much as algorithms
-
-## Practice Strategy
-
-Start with subtasks. Even partial solutions teach valuable lessons.
diff --git a/sites/reflections/src/content/puzzles/knights-tour-interactive.md b/sites/reflections/src/content/puzzles/knights-tour-interactive.md
deleted file mode 100644
index eec6960..0000000
--- a/sites/reflections/src/content/puzzles/knights-tour-interactive.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: "The Knight's Tour: An Interactive Exploration"
-description: "An interactive puzzle exploring the knight's tour problem with surprising mathematical connections."
-pubDate: "Jan 30 2024"
-image: "https://images.unsplash.com/photo-1528819622765-d6bcf132f793?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# The Knight's Tour: An Interactive Exploration
-
-Can a knight visit every square on a chessboard exactly once? This ancient puzzle hides deep mathematical structure.
-
-## The Basic Challenge
-
-Start with a 5×5 board. Can you find a knight's tour? What about one that returns to the starting square (a closed tour)?
-
-## Mathematical Beauty
-
-The problem connects to:
-- Hamiltonian paths in graphs
-- Warnsdorff's heuristic
-- Magic squares (surprisingly!)
-
-## The Algorithm
-
-The key insight: always move to the square with fewest onward moves. This simple heuristic works remarkably well.
-
-## Try It Yourself
-
-[Interactive board would go here - imagine clicking squares to build your tour]
-
-## Going Deeper
-
-For which board sizes do closed tours exist? The answer involves beautiful number theory.
diff --git a/sites/reflections/src/content/puzzles/projecteuler-favorites.md b/sites/reflections/src/content/puzzles/projecteuler-favorites.md
deleted file mode 100644
index 16988a9..0000000
--- a/sites/reflections/src/content/puzzles/projecteuler-favorites.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: "Project Euler: My Favorite Problems from 700+"
-description: "Curated problems from Project Euler that teach beautiful mathematical and algorithmic concepts."
-pubDate: "Feb 25 2024"
-image: "https://images.unsplash.com/photo-1635070041078-e363dbe005cb?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Project Euler: My Favorite Problems from 700+
-
-After solving 700+ Project Euler problems, these are the ones that changed how I think about mathematics and programming.
-
-## Problem 96: Su Doku
-
-Not just Sudoku solving - but solving 50 puzzles efficiently. The beauty is in combining constraint propagation with backtracking.
-
-## Problem 208: Robot Walks
-
-A counting problem that requires deep mathematical insight. The connection to complex numbers is unexpected and beautiful.
-
-## Problem 613: Pythagorean Ant
-
-Probability meets geometry in this elegant problem. The solution requires careful integration and surprising symmetry observations.
-
-## The Meta-Lesson
-
-Project Euler teaches you:
-- Mathematical intuition matters more than coding speed
-- There's always a clever approach
-- The journey matters more than the destination
-
-## Getting Started
-
-Don't aim for the leaderboard. Aim for understanding. Each problem is a teacher.
diff --git a/sites/reflections/src/content/puzzles/sudoku-variants.md b/sites/reflections/src/content/puzzles/sudoku-variants.md
deleted file mode 100644
index 1efd136..0000000
--- a/sites/reflections/src/content/puzzles/sudoku-variants.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-title: "Beyond Sudoku: Exploring Constraint Satisfaction Puzzles"
-description: "A journey through Sudoku variants and their algorithmic solutions."
-pubDate: "Feb 10 2024"
-image: "https://images.unsplash.com/photo-1580541631950-7282082b53ce?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Beyond Sudoku: Exploring Constraint Satisfaction Puzzles
-
-Sudoku is just the beginning. Let's explore variants that push the boundaries of logic puzzles.
-
-## Killer Sudoku
-
-Combine Sudoku with Kakuro - cages show sums, but no digit repeats within a cage.
-
-## Sandwich Sudoku
-
-The numbers outside show the sum of digits between 1 and 9 in that row/column. Simple rule, complex implications!
-
-## The Algorithm Connection
-
-These puzzles are constraint satisfaction problems. Techniques like arc consistency and backtracking with constraint propagation solve them efficiently.
-
-## Create Your Own
-
-What happens if we add chess knight move constraints? The design space is infinite!
diff --git a/sites/reflections/src/content/reflections/eight-self-sabotaging-behaviors/index.md b/sites/reflections/src/content/reflections/eight-self-sabotaging-behaviors/index.md
new file mode 100644
index 0000000..1c600ee
--- /dev/null
+++ b/sites/reflections/src/content/reflections/eight-self-sabotaging-behaviors/index.md
@@ -0,0 +1,135 @@
+---
+title: "Eight Self-Sabotaging Behaviors"
+description: "Putting this thread in one place. --- 🧵 @fortelabs recently finished the opening keynote on the Second Brain summit, which incidentally has a great lineup including a panel dis..."
+pubDate: "2022-03-15"
+authorName: "Neeldhara"
+sourceCategories: ["funda", "twitterthread"]
+sourcePath: "eight-self-sabotaging-behaviors/index.qmd"
+---
+
+Putting [this thread](https://twitter.com/neeldhara/status/1503551801378881541) in one place.
+
+---
+
+🧵 @fortelabs recently finished the opening keynote on [the Second Brain summit](https://twitter.com/fortelabs/status/1498668781585014785?ref_src=twsrc%5Etfw), which incidentally has a great lineup including a panel discussion on PKM through the lens of ADHD. Ironically, I didn’t quite take notes but I think the themes also feature in this short video:
+
+<iframe width="560" height="315" src="https://www.youtube.com/embed/lKM2jE2PygY" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
+
+The live session was fun because of a super engaged chat — everyone had great suggestions for managing some of these (surprisingly common?) behaviors.
+
+I’ll not share the premise (it’s self-explanatory + there’s the video), but the discussion involved three parts:
+
+1. why it’s an issue;
+
+2. why-do-we-do-this-to-ourselves;
+
+3. how do we not keep doing it 😀
+
+I’ll share a tweet-length summary of my takeaways.
+
+>Caveat I: 280 chars! Twitter isn’t the platform for nuance. 😅
+>
+>Caveat II. Should go without saying, but all of this gyaan needs to be tempered with context, which was a frequently used word throughout the session!
+
+---
+
+> **Caution**
+> 
+> ## Starting over (again and again)
+> 
+> ⚠️  Not learning from previous mistakes.
+> 
+> 🤔  False sense of accomplishment, dopamine hit from a clean slate, FOMO (new tools).
+> 
+> 💡 Start simple, iterate slowly, resist looking at shiny new objects.
+> 
+
+
+> **Caution**
+> 
+> ## Feeling guilty
+> 
+> ⚠️  Can’t win when you are at war with yourself.
+> 
+> 🤔  Probably comes from knowing you’ll trip again.
+> 
+> 💡 Extend to yourself the same courtesy and patience you’d show to a friend, consider replacing guilt with curiosity.
+> 
+
+
+> **Caution**
+> 
+> ## Perfectionism
+> 
+> ⚠️  Not making mistakes is a risky way to live.
+> 
+> 🤔  Feeds ego, sense of control and safety, and you think you push yourself harder with lofty standards.
+> 
+> 💡 Aim for B+, fail in public and value it — can be a relief to not have to keep up with the perfect image.
+> 
+
+
+> **Caution**
+> 
+> ## Do *all* the research first
+> 
+> ⚠️  When overdone, really procrastination in disguise.
+> 
+> 🤔  Creates an illusion of getting work done. Paranoia associate with diving in without preparation.
+> 
+> 💡 Second brains are not for archival, but production. Iterate often. Timebox research.
+> 
+
+
+> **Caution**
+> 
+> ## Going big
+> 
+> ⚠️  Ambition dominates the public discourse around goal-setting. Big goals are not problematic until they get in the way.
+> 
+> 🤔  Ego boosted, creates a potentially misguided sense of being inspired.
+> 
+> 💡 Break things down, take incremental (read: realistic!) steps.
+> 
+
+
+> **Caution**
+> 
+> ## Doing it all yourself
+> 
+> ⚠️  Potentially limiting.
+> 
+> 🤔  A desire for respect or credit, and the sense that nobody can do this as well as me.
+> 
+> 💡 Delegate when appropriate, especially when looking to scale and/or diversify.
+> 
+
+
+> **Caution**
+> 
+> ## Comparing yourself to others
+> 
+> ⚠️  Potentially depressing.
+> 
+> 🤔  Self-pity, and an excuse to not even try.
+> 
+> 💡 Compare to past you. Read your old journal entries. (Also, journal.)
+> 
+
+
+> **Caution**
+> 
+> ## Postpone gratification
+> 
+> ⚠️  For something to be sustainable, it needs to be fun!
+> 
+> 🤔  Traditional positive quality.
+> 
+> 💡 Enjoy the journey because nobody knows the destination. Live in the moment, find joy in the small things, be present. Also, music for instant gratification!
+
+
+Do check out the [Second Brain Summit](https://www.secondbrainsummit.com/) for the remaining sessions.
+
+I think you get a link to a recording if you’re registered for a session, at least this was the case for me with the opening session.
+
+The community attending this is also [on a slack](https://basb.io/slack).
diff --git a/sites/reflections/src/content/reflections/exportober/2021-tracker/index.md b/sites/reflections/src/content/reflections/exportober/2021-tracker/index.md
new file mode 100644
index 0000000..5ca18fe
--- /dev/null
+++ b/sites/reflections/src/content/reflections/exportober/2021-tracker/index.md
@@ -0,0 +1,34 @@
+---
+title: "Exportober 2021"
+description: "The Leaderboard The Tweets What was this about again? You can find the original announcement here and more specifics clarifying the format (or the lack of it) here. Here's the s..."
+pubDate: "2021-09-25"
+authorName: "Neeldhara"
+sourceCategories: ["exportober"]
+sourcePath: "exportober/2021-tracker/index.qmd"
+---
+
+## The Leaderboard
+
+<iframe class="airtable-embed" src="https://airtable.com/embed/shrVfH6aH5n09dDY0?backgroundColor=yellow&viewControls=on" frameborder="0" onmousewheel="" width="100%" height="533" style="background: transparent; border: 1px solid #ccc;"></iframe>
+
+## The Tweets
+
+<iframe class="airtable-embed" src="https://airtable.com/embed/shrD3Cw0YYB79LzDP?backgroundColor=yellow&viewControls=on" frameborder="0" onmousewheel="" width="100%" height="533" style="background: transparent; border: 1px solid #ccc;"></iframe>
+
+## What was this about again?
+
+You can find the original announcement [here](../2021/) and more specifics clarifying the format (or the lack of it) [here](../about/). Here's the short version:
+
+- Put up a piece of content everyday between 27th September and 30th October, with the possibility of skipping one day per week;
+- Post a link to your content on Twitter with #exportober
+- That's it, actually. 🤷‍♀️
+
+> **Aside:** 📝 If you'd like to participate ~~you can sign up below~~; and if you'd like to help, please encourage everyone participating by checking out the tweets coming in above!
+
+Psst. It's quite fine to sign up even if you're reading this after the 27th of September. The automated tracking exercise here will stop after the 30th of October, so you can be a part of this by just contributing in this window. It certainly does't *have* to be daily and it doesn't *have* to be 30 things, although I found those to be useful default targets to work with for myself.
+
+## Sign up!
+
+~~While you can participate simply by using #exportober in your tweets, it'll be great if you could explicitly enter your Twitter username in the form below, so we can check in on each other!~~ 🤝
+
+While I'm not going to write a Twitter bot that will send you daily reminders over DM, I do hope to create a separate page for each registered participant at the end of the challenge that shows off just their entries in one place, so it's helpful to know who you are 😀
diff --git a/sites/reflections/src/content/reflections/exportober/2021/index.md b/sites/reflections/src/content/reflections/exportober/2021/index.md
new file mode 100644
index 0000000..937e440
--- /dev/null
+++ b/sites/reflections/src/content/reflections/exportober/2021/index.md
@@ -0,0 +1,42 @@
+---
+title: "An Invitation to Exportober 2021"
+description: "Note 📝 Update: You can now track everyone's progress from here! Tip You can also check out a little more about the format, intent and background here. As you can see — at least..."
+pubDate: "2021-09-19"
+authorName: "Neeldhara"
+sourceCategories: ["exportober"]
+sourcePath: "exportober/2021/index.qmd"
+---
+
+> **Note**
+> 
+> 📝 Update: You can now track everyone's progress [from here](../2021-tracker/)!
+
+
+> **Tip**
+> 
+> You can also check out a little more about the format, intent and background [here](../about/).
+
+
+As you can see — at least at the time of this writing — this is a blog under construction with some mild ambition, going by the long list of empty categories on the homepage.
+
+I've heard a lot about the effectiveness of something something *public* something something *accountability*, so I'm going to give this a shot: if there's anyone else who wants a bit of a jumpstart and encouragement for getting into the habit of putting stuff out there, this is for you!
+
+Presenting the EXPress yOuR Thoughts, i.e, export, challenge.
+
+Here be some rules, or not, make this your own!
+
+1. Put something out there — could be an essay, a video, a sketchnote, some code, a piece of music, a photograph — I think the only criteria is that this should be something you put together that you feel compelled to share, and something that can be accessed via a public URL. I suppose quotes and curated round-ups are good too, but ideally you want this to be something that has a bit of you in it.
+2. Share it on Twitter with #exportober (umm, the export challenge in October 😬 ... it had to be something that wasn't already taken so I can scrape it off and put it up in one place, and everyone participating can keep an eye out on others participating — the general hope is that everyone finds themselves encouraged by everyone else 🎉).
+3. I'm going to find a way of listing everything that comes up starting **27th September**. This gives you five weeks until the end of October. Try and get something up everyday - this puts the challenge in the Export Challenge 😀  That said, allowing ourselves one cheat day per week means that we all hopefully end up with 30 things by the 30th of October. Yays 🤞
+4. Since I'll hopefully find a way of tracking all the content tagged this way and automatically pushing it to a page where we can find it all in one place, please don't put up anything illegal or damaging. Other than this, practically anything goes, but please do respect the basic idea, which is is to build up some positive vibes and keep this a fun exercise!
+
+So I hope you spend the coming week getting setup — figure out what you want to do and how you'll do it, and maybe even cheating a little and preparing some buffer content for the rainy days? We've already had some great suggestions for tools you can use to get started:
+
+
+<blockquote class="twitter-tweet" data-conversation="none"><p lang="en" dir="ltr">GitHub pages is great for this. I don&#39;t use Markdown, but it still works as a quick, lightweight publishing system, automatic ssh setup, etc. Since I store the content on GitHub anyway, everything is nicely unified.</p>&mdash; ShriramKrishnamurthi (@ShriramKMurthi) <a href="https://twitter.com/ShriramKMurthi/status/1439625380055425033?ref_src=twsrc%5Etfw">September 19, 2021</a></blockquote> 
+
+<blockquote class="twitter-tweet" data-conversation="none"><p lang="en" dir="ltr">May not commit for mutual accountability :) But a suggestion.<br><br>Instead of blogging platforms, how about markdown/Jupyter notebooks in a github repo and/or short code/docs as github gists?<br><br>Can use versioning to improve - no need to get the content &quot;right&quot; at the first &quot;publish&quot;.</p>&mdash; A. Sundararajan (@sundararajan_a) <a href="https://twitter.com/sundararajan_a/status/1439609462759706627?ref_src=twsrc%5Etfw">September 19, 2021</a></blockquote> 
+
+
+Throw in your Twitter username in the form below to add your name to the list of people who ~~are thinking about~~ will be participating! The list will evolve automatically below, and I'll probably clean it out of spurious entries manually every so often.
+> **Aside:** Thanks to everyone who participated! The form is no longer relevant, but you can check out the posts by looking for #exportober on Twitter :)
diff --git a/sites/reflections/src/content/reflections/exportober/2022-tracker/index.md b/sites/reflections/src/content/reflections/exportober/2022-tracker/index.md
new file mode 100644
index 0000000..ff3655e
--- /dev/null
+++ b/sites/reflections/src/content/reflections/exportober/2022-tracker/index.md
@@ -0,0 +1,30 @@
+---
+title: "Exportober 2022"
+description: "The Leaderboard The Tweets What was this about again? You can find the original announcement here and more specifics clarifying the format (or the lack of it) here. Here's the s..."
+pubDate: "2022-10-07"
+authorName: "Neeldhara"
+sourceCategories: ["exportober"]
+sourcePath: "exportober/2022-tracker/index.qmd"
+---
+
+## The Leaderboard
+
+<iframe class="airtable-embed" src="https://airtable.com/embed/shrjgp87jlNqDMCy4?backgroundColor=yellow&viewControls=on" frameborder="0" onmousewheel="" width="100%" height="533" style="background: transparent; border: 1px solid #ccc;"></iframe>
+
+## The Tweets
+
+<iframe class="airtable-embed" src="https://airtable.com/embed/shrwXyP8mGB3KH86i?backgroundColor=yellow&viewControls=on" frameborder="0" onmousewheel="" width="100%" height="533" style="background: transparent; border: 1px solid #ccc;"></iframe>
+
+## What was this about again?
+
+You can find the original announcement [here](../2022/) and more specifics clarifying the format (or the lack of it) [here](../about/). Here's the short version:
+
+- Put up a piece of content everyday between 1st October and 30th October, with the possibility of skipping one day per week;
+- Post a link to your content on Twitter with #exportober
+- That's it, actually. 🤷‍♀️
+
+Psst. It's quite fine to sign up even if you're reading this after the 1st of October. The automated tracking exercise here will stop after the 15th of November, so you can be a part of this by just contributing in this window. It certainly does't *have* to be daily and it doesn't *have* to be 30 things, although I found those to be useful default targets to work with for myself.
+
+<!-- ## Sign up! -->
+
+<!-- While I'm not going to write a Twitter bot that will send you daily reminders over DM, I do hope to create a separate page for each registered participant at the end of the challenge that shows off just their entries in one place, so it's helpful to know who you are 😀 -->
diff --git a/sites/reflections/src/content/reflections/exportober/about/index.md b/sites/reflections/src/content/reflections/exportober/about/index.md
new file mode 100644
index 0000000..0e2c6af
--- /dev/null
+++ b/sites/reflections/src/content/reflections/exportober/about/index.md
@@ -0,0 +1,91 @@
+---
+title: "About Exportober"
+description: "In a massively impulsive move nudged by some Twitter feedback, I recently launched the Exportober challenge. The TL;DR version: - Put up a piece of content everyday between 27th..."
+pubDate: "2021-09-24"
+authorName: "Neeldhara"
+sourceCategories: ["exportober"]
+sourcePath: "exportober/about/index.qmd"
+---
+
+In a massively impulsive move nudged by some Twitter feedback, I recently launched [the Exportober challenge](../2021/).
+
+The TL;DR version:
+
+- Put up a **piece of content*** everyday between 27th September and 30th October, with the possibility of skipping one day per week;
+- Post a link to your content on Twitter with #exportober
+- That's it, actually. 🤷‍♀️
+
+<blockquote class="twitter-tweet"><p lang="en" dir="ltr">Anyone else procrastinating on starting a blog, CS or otherwise? Would you be interested in being held mutually accountable for a few weeks to overcome the initial inertia? <br><br>Do let me know! I’ll try to setup something systematic-looking if there’s interest 🙂</p>&mdash; Neeldhara (@neeldhara) <a href="https://twitter.com/neeldhara/status/1439607978445869057?ref_src=twsrc%5Etfw">September 19, 2021</a></blockquote> 
+
+
+## What's allowed in #exportober?
+
+I was deliberately vague about the terms-and-conditions that goes with the piece of content piece above. The rules I mentioned were minimal: since there are no restrictions of age, keep the content SFW and generally legal. Other than that, anything goes, for example:
+
+- Can I doodle? Yes.
+- Can I meme? Yes.
+- Can I make a comic? Yes.
+- Can I quip? Yes.
+- Can I tweet a thread? Yes.
+- Can I tweet a single tweet? Yes.
+- Can I song and/or hum and/or dance? Yes.
+- Can I react? I am unfamiliar with this genre, but yeah, why not?
+- Can I just quote? Uhh, ok-fine, sure — maybe be sure to include a reaction?
+- Can I commit? Yes, please! Oh, you mean — can it be a GitHub commit? Right, yeah, sure.
+
+
+<blockquote class="twitter-tweet" data-conversation="none"><p lang="en" dir="ltr">One a day is a lot! (Unless tweets count). I used to blog regularly but not even one a week at its peak, I think.</p>&mdash; Rahul Siddharthan (@rsidd120) <a href="https://twitter.com/rsidd120/status/1440537832980828165?ref_src=twsrc%5Etfw">September 22, 2021</a></blockquote> 
+
+<blockquote class="twitter-tweet"><p lang="en" dir="ltr">in case anyone is looking for inspiration, in true student fashion, i am already planning on cheating by turning all the math puns i have in mind to comics [&#39;ring arthur and his knights of the round table&#39; but where ring arthur is a noncommutative ring without unity]</p>&mdash; tiiiiredddd (@vuisnotabot) <a href="https://twitter.com/vuisnotabot/status/1440752412298399744?ref_src=twsrc%5Etfw">September 22, 2021</a></blockquote> 
+
+
+As you can see, there are no restrictions on format or length or quality. It can be whatever you want, and however long or short you want it to be. The point is to *get into the habit* of putting a bit of yourself into something tangible that you'd want to share.
+
+So while you could technically schedule thirty pieces of Harry Potter trivia in advance — *that* would kind of defeat the purpose.
+
+## Is this for me? #whybother with #exportober
+
+In general, I imagine only you would know if this is for you — this may not be a priority or a point of interest for you right now, but if you're reading this, possibly your interest is at least mildly piqued?
+
+What this is about is setting aside some time for yourself and to participate alongside friends who're in it for fun and profit:
+
+<blockquote class="twitter-tweet"><p lang="en" dir="ltr">We often avoid taking action because we think &quot;I need to learn more,&quot; but the best way to learn is often by taking action.</p>&mdash; James Clear (@JamesClear) <a href="https://twitter.com/JamesClear/status/1308857494983323650?ref_src=twsrc%5Etfw">September 23, 2020</a></blockquote> 
+
+- The fun bit is in the making and sharing.
+- The profit bit is the hope that we trick ourselves into making this a bit of a regular habit for life.
+
+Longer term, you may or may not want to be sharing or publishing on a daily basis. But hopefully, longer term, **you are engaged with the process on a regular basis**.
+
+Personally, there's almost nothing that I do consistently on a daily basis, not counting the things one needs to do continue being alive. I'd like to see if I can change that a bit^[c.f. the next section for a different perspective.], and apparently doing such things bit by bit — and with some public commitment — [is a good idea](https://jamesclear.com/atomic-habits), hence the micro-nature of the challenge.
+
+<blockquote class="twitter-tweet" data-conversation="none"><p lang="en" dir="ltr">So overall I’ve gotten to a point where I’m just afraid to even think about putting something together because I think it’s an unrealistic commitment of time. <br><br>I’m also really bad at chunking - everything I do of this sort manifests at the wrong end of an all-nighter 🙈</p>&mdash; Neeldhara (@neeldhara) <a href="https://twitter.com/neeldhara/status/1439682627837980675?ref_src=twsrc%5Etfw">September 19, 2021</a></blockquote> 
+
+## I want to be in, but I stoop no lower than meaningful masterpieces...
+
+Hmm. One way that you could still make this work for you is to build out your masterpiece bit by bit. If it's a tutorial, you could plan it out in advance and work through one coherent section a day. If it's a sketch, you could share your partial progress as you go along, and even put it together in a timelapse at the end? That would be great to see!
+
+There are some types of long-form content that aren't naturally amenable to this type of chunking; say you want to put together a video exposition, make an origami sculpture, or crochet a Klein bottle. In this situation, you could either use the challenge to document your process and progress; or you could just claim to engage in #exportoberlite with a reduced frequency of production — say once a week, or one masterpiece at the end — you'll just have to still tweet it out so I can catalog it ❤️
+
+<blockquote class="twitter-tweet"><p lang="en" dir="ltr">I really don’t like the illusion that there is one process for making and that it involves writing every day. Thinking is work to. So is reading. So is doing things that seem unrelated to writing. Our brains are always thinking about what we’re making, whether we’re typing or not</p>&mdash; ChristianAntonGerard (@CAGerardPoet) <a href="https://twitter.com/CAGerardPoet/status/1221128922982690818?ref_src=twsrc%5Etfw">January 25, 2020</a></blockquote> 
+
+Also, while on the subject of masterpieces, there's the [parable of the pots](https://austinkleon.com/2020/12/10/quantity-leads-to-quality-the-origin-of-a-parable/). On the other hand, everyone does have their own process, and the idea isn't to force a format: this process is temporary, flexible, and optional 🙌
+
+## This sounds like fun, but I have no idea what to make.
+
+Oooh. Maybe just ping on Twitter if you are in this situation. I do imagine that there are folks who have more ideas than they can handle, so if you have the bandwidth, it'll even out nicely! For some starter inspiration, just in case it is useful, here are some of the post types that I'm planning for the duration of this challenge, in roughly increasing order of desperation:
+
+1. Trying some of the [Chai and Why? experiments](https://www.tifr.res.in/~outreach/chai_and_why.html) and documenting ~~any accidents~~ learnings.
+2. Puzzles and programming contest roundups.
+3. Lecture notes for classes/talks I'm teaching and/or attending.
+4. Highlights from whatever podcasts I'm tuned into.
+5. Clean up draft essays from previous lives.
+6. Random doodles. And VSCode keyboard shortcuts.
+7. Hot takes on inconsequential debates.^[Let me know if you want prompts.]
+
+I also have a few black holes nurtured over time — I'm looking at you, all my Read-It-~~Never~~Later apps, the starred section in my RSS app, my YouTube watchlist, and relatives. Maybe about time to go down some of these rabbit holes with the excuse of commentary to follow.
+
+So yes, that'll be all for now! Let's see how this goes 🤞 Meanwhile, [please hop on](../2021/) and [spread the word](https://twitter.com/neeldhara/status/1439668714178105347) for all of us? Thank you! 🎉
+
+---
+
+PS. You might be curious about what participating will *look like*. I'm trying to setup a separate page for each participant in the challenge that will pull in all your tagged tweets. I'll share a preview soon!
diff --git a/sites/reflections/src/content/reflections/iit-rankings/index.md b/sites/reflections/src/content/reflections/iit-rankings/index.md
new file mode 100644
index 0000000..451510c
--- /dev/null
+++ b/sites/reflections/src/content/reflections/iit-rankings/index.md
@@ -0,0 +1,56 @@
+---
+title: "The Only Fair Ranking of IITs"
+description: "Don't like the ranking? Try again . Tip Methodology: adapted from here. The program takes all the available knowledge in the universe and extrapolates a score for each IIT using..."
+pubDate: "2022-11-24"
+authorName: "Neeldhara"
+sourceCategories: ["funda"]
+sourcePath: "iit-rankings/index.qmd"
+---
+
+<p>Don't like the ranking? <a href=".">Try again</a>.</p>
+
+> **Tip**
+> 
+> # Methodology: adapted from [here](https://sarielhp.org/cgi-bin/cs_ranking).
+> 
+> The program takes all the available knowledge in the universe and extrapolates a score for each IIT using state of the art algorithmic techniques (i.e., deep guessing). To resolve ties, the program also computes a secondary score which is a random number. The program next computes a weighted average of the two scores - the weight assigned to the first score is based on its scientific value and merit, and is thus zero, and the remaining weight is assigned to the secondary score (i.e., 1). The program then sort and output the departments in decreasing ordering of their weighted scores.
+> 
+
+
+[Inspiration](https://sarielhp.org/cgi-bin/cs_ranking) {{< bi arrow-left-circle-fill >}} Check this page for a ranking of computer science departments.
+
+---
+
+```{ojs}
+
+import { shuffle } from "./shuffle.js"
+
+arr = ["IIT Kharagpur",
+"IIT Bombay",
+"IIT Madras",
+"IIT Kanpur",
+"IIT Delhi",
+"IIT Guwahati",
+"IIT Roorkee",
+"IIT Ropar",
+"IIT Bhubaneswar",
+"IIT Gandhinagar",
+"IIT Hyderabad",
+"IIT Jodhpur",
+"IIT Patna",
+"IIT Indore",
+"IIT Mandi",
+"IIT (BHU) Varanasi",
+"IIT Palakkad",
+"IIT Tirupati",
+"IIT (ISM) Dhanbad",
+"IIT Bhilai",
+"IIT Dharwad",
+"IIT Jammu",
+"IIT Goa"];
+x = shuffle(arr);
+y = document.getElementById("quarto-document-content");
+
+y.innerHTML += "1. " + x[0] + "<br> 2. " + x[1] +  "<br> 3. " + x[2] +  "<br> 4. " + x[3] +  "<br> 5. " + x[4] +  "<br> 6. " + x[5] +  "<br> 7. " + x[6] +  "<br> 8. " + x[7] +  "<br> 9. " + x[8] +  "<br> 10. " + x[9] +  "<br> 11. " + x[10] +  "<br> 12. " + x[11] +  "<br> 13. " + x[12] +  "<br> 14. " + x[13] +  "<br> 15. " + x[14] +  "<br> 16. " + x[15] +  "<br> 17. " + x[16] +  "<br> 18. " + x[17] +  "<br> 19. " + x[18] +  "<br> 20. " + x[19] +  "<br> 21. " + x[20] +  "<br> 22. " + x[21] +  "<br> 23. " + x[22];
+
+```
diff --git a/sites/reflections/src/content/reflections/iit-rankings/shuffle.js b/sites/reflections/src/content/reflections/iit-rankings/shuffle.js
new file mode 100644
index 0000000..41551ed
--- /dev/null
+++ b/sites/reflections/src/content/reflections/iit-rankings/shuffle.js
@@ -0,0 +1,22 @@
+export function shuffle(array) {
+  let currentIndex = array.length,  randomIndex;
+
+  // While there remain elements to shuffle.
+  while (currentIndex != 0) {
+
+    // Pick a remaining element.
+    randomIndex = Math.floor(Math.random() * currentIndex);
+    currentIndex--;
+
+    // And swap it with the current element.
+    [array[currentIndex], array[randomIndex]] = [
+      array[randomIndex], array[currentIndex]];
+  }
+
+  return array;
+}
+
+// Used like so
+var arr = [2, 11, 37, 42];
+shuffle(arr);
+console.log(arr);
diff --git a/sites/reflections/src/content/reflections/imposter-syndrome.md b/sites/reflections/src/content/reflections/imposter-syndrome.md
deleted file mode 100644
index e0a77e0..0000000
--- a/sites/reflections/src/content/reflections/imposter-syndrome.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: "Imposter Syndrome in Academia: A Confession"
-description: "An honest conversation about feeling like a fraud, even after years of success."
-pubDate: "Feb 25 2024"
-image: "https://images.unsplash.com/photo-1517048676732-d65bc937f952?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Imposter Syndrome in Academia: A Confession
-
-Even after publishing papers, winning grants, and teaching thousands of students, the voice whispers: "They'll find out you don't belong."
-
-## The Paradox
-
-The more you know, the more you realize you don't know. Expertise breeds humility, which feeds the imposter.
-
-## What Helps
-
-- Keeping a "wins" journal - evidence against the imposter
-- Mentoring others - seeing your knowledge help someone
-- Talking about it - you're not alone in this
-
-## The Silver Lining
-
-Maybe imposter syndrome keeps us humble, curious, and always learning. Maybe it's not a bug, but a feature.
-
-## Moving Forward
-
-I may never silence the voice completely. But I've learned to acknowledge it and keep going anyway.
diff --git a/sites/reflections/src/content/reflections/on-career-choices/calvin-21stcentury.jpg b/sites/reflections/src/content/reflections/on-career-choices/calvin-21stcentury.jpg
new file mode 100644
index 0000000..60a6dc6
Binary files /dev/null and b/sites/reflections/src/content/reflections/on-career-choices/calvin-21stcentury.jpg differ
diff --git a/sites/reflections/src/content/reflections/on-career-choices/cstheoryvpractice.png b/sites/reflections/src/content/reflections/on-career-choices/cstheoryvpractice.png
new file mode 100644
index 0000000..1fa368f
Binary files /dev/null and b/sites/reflections/src/content/reflections/on-career-choices/cstheoryvpractice.png differ
diff --git a/sites/reflections/src/content/reflections/on-career-choices/index.md b/sites/reflections/src/content/reflections/on-career-choices/index.md
new file mode 100644
index 0000000..1de4e58
--- /dev/null
+++ b/sites/reflections/src/content/reflections/on-career-choices/index.md
@@ -0,0 +1,35 @@
+---
+title: "On Career Choices"
+description: "Tip A version of this article was featured in A Lesson from IIT , a column on the Indian Express. The link to the column is here, and this is the link to the present article. Ma..."
+pubDate: "2023-05-26"
+authorName: "Neeldhara"
+sourceCategories: ["funda"]
+sourcePath: "on-career-choices/index.qmd"
+---
+
+> **Tip**
+> 
+> A version of this article was featured in _A Lesson from IIT_, a column on the Indian Express. The link to the column is [here](https://indianexpress.com/about/a-lesson-from-iit/), and [this](https://indianexpress.com/article/education/a-lesson-from-iit-how-do-you-figure-out-your-interest-if-engineering-is-right-choice-iit-gandhinagar-jee-main-jee-advanced-2023-8629639/) is the link to the present article. Many thanks to [Ritika Chopra](https://indianexpress.com/profile/author/ritika-chopra/) for prompting me to write this, and for not giving up on me as I took my time :)
+> 
+> Thanks are also due to friends Manasa, Jyothi, and Sharmistha for going over early versions of this writeup and sharing their thoughts!
+
+
+During school, my earliest exposure to the notion of being an engineer was an at-the-time popular audio clip called _The Knack_, in which a doctor is diagnosing a kid with a condition involving extreme intuition for all things mechanical and electrical. It is implied that having "the knack" is not compatible with a normal life, since the kid is now destined to... be an engineer. This causes his mother to experience much concern and grief. The episode inspired me to keep a polite but firm distance from all things engineering, conveniently including the entrance exams meant to unlock the gates of the IITs.
+
+College admissions are rife with two types of scenarios that are less than ideal: students ending up in programs that are not their cup of tea, and students missing out on experiences that would have been right up their alley. These mismatches are cumulatively expensive: there is the price paid in misallocated resources, and then there’s the personal cost of training for programs that eventually turn out to be a poor fit, which is typically very substantial.
+
+Some of this can be mitigated with an appreciation of what these programs entail, and what the campuses have to offer. The IITs are known predominantly for their undergraduate programs in the traditional engineering disciplines. However, several of them also host excellent programs in the sciences. Further, there are an increasing number of undergraduate programs that have interdisciplinary themes (such as the Btech program in [Civil and Infrastructure Engineering with specialization in Smart Infrastructure](https://iitj.ac.in/department/index.php?id=ug_program&dept=civil) at IIT Jodhpur) and a focus on emerging technologies and areas (for instance, the BTech program in [Artificial Intelligence](https://ai.iith.ac.in/programs/btech.html) at IIT Hyderabad or the undergraduate program in [Design](https://twitter.com/iitdelhi/status/1574782831221698562) at IIT Delhi).
+
+Currently, awareness about these opportunities is mostly a heady mix of word of mouth, Quora answers, vibes from coffee-table conversations at coaching centers, and placement statistics on popular media. Impressions of what campus life entails is also largely a combination of imagination fueled by things seen on, say, Netflix and the like. However, if you are a prospective student or a parent of one, you would do well to go beyond these secondary sources of intelligence and get some first-hand experience.
+
+Most IITs host open days every so often: these are special days when the campuses are open to anyone to walk in, and professors and students from the organization delight in sharing what they are up to with accessible demonstrations or lab tours. A recent example is the [G20-Ignite Sci-Tech fair](https://students.iitgn.ac.in/ignite) which hosted hundreds of school students at the IIT Gandhinagar campus. Often, even one such experience can trigger an inner calling, helping you identify the thing you want to do for life – or at least for a substantial duration.
+
+You could also go beyond the glimpses offered by open days. Watch out for opportunities to collaborate over small projects. For example, the [Center for Creative Learning at IIT Gandhinagar](https://ccl.iitgn.ac.in/) welcomes high school students for short term projects over summer, and students who do well in courses on the [NPTEL](https://nptel.ac.in/) platform have a shot at internships with the instructors of those courses. Many professors delight in talking to students: check out the various seasons of [Talk to a Scientist](https://www.talktoascientistindia.com/home), for example. You can also ask your school to reach out to professors at nearby institutions for an interactive session, or approach organizations like [INYAS](https://inyas.in/) that focus deeply on outreach activities at the school level. Finally, several IITs also host bootcamps, hackathons, and so on: they are usually announced on their websites and social media channels, so keep an eye out for these!
+
+Having said all this, a choice of career – or more immediately, a branch or stream – does not have to be prompted necessarily by an intense love at first sight. The routes leading to your final pursuit(s) can be potentially meandering, and not having an inner voice abundant in clarity should be no cause for alarm. Examples of this abound, and I’ll share a representative one. [Ronald Graham](https://en.wikipedia.org/wiki/Ronald_Graham) is arguably best-known as an American mathematician who made fundamental contributions to combinatorics. Because his father worked in various jobs related to oil fields and shipbuilding, he moved schools often. He did not study in any school for more than eighteen months and often studied in grades higher than what would have been normal for his age.
+
+At the age of 15, Graham won a Ford Foundation scholarship to the University of Chicago, where he spent three years learning gymnastics. Because of his outstanding performance in math on the scholarship examinations, he did not (have to) take any mathematics courses. After the duration of the scholarship, he moved to the University of California at Berkeley, where he majored in electrical engineering. During this time, a one-off number theory course with D H Lehmer “fired his imagination for the subject”. After four subsequent years in the Air Force, during which he also earned a B.S. in physics, he returned to UC Berkeley where he completed his Ph.D. in mathematics with D H Lehmer as his thesis advisor.
+
+All this is to say that life can be — and typically is — highly non-linear. I would argue that as much as we like to imagine being in control, planning one’s future down to summer-vacation-wise bucket lists is perhaps somewhat excessive. Your first branch and your first job does not have to be your last: for more evidence, I recommend reading Tim Ferriss’ book, [Tribe of Mentors](https://www.amazon.in/Tribe-Mentors-Short-Advice-World/dp/1328994961). Now, you might be prone to making your choices after optimizing for a dozen variables or more, or you might prefer leaving your destiny to the gods of randomness. I believe somewhere in between, there is an approach more reasonable than either extreme: make an informed choice after investing a finite amount of your own time and energy into understanding what actually lies in store.
+
+The IITs are now far from being the only ticket to the good life and a powerful alumni network: if these are your main motivators, you might consider exploring less painful pathways to the same outcomes. If not, allow yourself the space to let your instincts come to the fore, and follow them to make your choices. This will maximize the chances that you will end up in a meaningful journey that involves truly enjoying what the programs have to offer, instead of being in a situation where you have simply transitioned from one rat race into another.
diff --git a/sites/reflections/src/content/reflections/on-teaching/calvin-21stcentury.jpg b/sites/reflections/src/content/reflections/on-teaching/calvin-21stcentury.jpg
new file mode 100644
index 0000000..60a6dc6
Binary files /dev/null and b/sites/reflections/src/content/reflections/on-teaching/calvin-21stcentury.jpg differ
diff --git a/sites/reflections/src/content/reflections/on-teaching/cstheoryvpractice.png b/sites/reflections/src/content/reflections/on-teaching/cstheoryvpractice.png
new file mode 100644
index 0000000..1fa368f
Binary files /dev/null and b/sites/reflections/src/content/reflections/on-teaching/cstheoryvpractice.png differ
diff --git a/sites/reflections/src/content/reflections/on-teaching/index.md b/sites/reflections/src/content/reflections/on-teaching/index.md
new file mode 100644
index 0000000..8cd7614
--- /dev/null
+++ b/sites/reflections/src/content/reflections/on-teaching/index.md
@@ -0,0 +1,93 @@
+---
+title: "On Teaching"
+description: "Note These are some parts of the teaching statment that I wrote roughly seven years ago, updated slightly in the interest of clarity and additional context. ::: -- A teacher doe..."
+pubDate: "2022-09-05"
+authorName: "Neeldhara"
+sourceCategories: ["funda"]
+sourcePath: "on-teaching/index.qmd"
+---
+
+<!--
+> **Note**
+> 
+> These are some parts of the teaching statment that I wrote roughly seven years ago, updated slightly in the interest of clarity and additional context.
+> ::: -->
+> 
+> > _A teacher does not teach, a student learns._
+> >
+> > --- snippet from [this interview](https://www.facebook.com/425094961174523/videos/5530977776968824/) of [Ustad Zakir Hussain](https://en.wikipedia.org/wiki/Zakir_Hussain_(musician))
+> 
+> 
+> 
+> I'll pose some how/what/why questions in the context of teaching.
+> 
+> 
+> ## How
+> 
+> The last couple of decades, especially the last few years, have seen dramatic changes in how information is communicated. A lot of learning happens in online communities, for instance, question-and-answer websites like Quora and StackExchange. Thanks to folks who invest time on these platforms, expert help seems to be nearer than ever before. Specialized and snark-free communities on Discord/Slack/Telegram are enabling peer-to-peer learning at global scale. [I keep hearing that Quora is not what it used to be, but as long as [Thomas Cormen](https://www.quora.com/profile/Thomas-Cormen-1/) is an active user, I am positive it remains a valuable resource.]{.aside}
+> 
+> Books are beginning to be injected with exciting new technology: [CodeMirror](https://codemirror.net/index.html) makes code interactive and runnable, while tools like [PythonTutor](https://pythontutor.com/) can help with visualizing what happens behind-the-scenes when code is executed. [Say](https://github.com/denysdovhan/wtfjs) [what](https://www.destroyallsoftware.com/talks/wat) [you](https://wtfjs.com/) [want](https://martin-thoma.com/javascript-wtf/) about JavaScript, but the interactivity that it brings to the written medium has helped make reading less passive. Some of my favorite interactive texts include [Seeing Theory](https://seeing-theory.brown.edu/), [Probabilistic Models of Cognition](http://probmods.org/), courses on [Brilliant](https://brilliant.org/), [Mathigon](https://mathigon.org/), and essays from [Nicky Case](https://ncase.me/), [Minute Labs](https://minutelabs.io/), and others on [Explorables](https://explorabl.es/).The name "PythonTutor" is slightly misleading, since the website also lets you visualize code snippets written in C, C++, Java, and JavaScript.
+> 
+> 
+> And finally there are the online courses. At the time of this writing, it has been just a little over two decades since [MIT's Open Course Ware](https://en.wikipedia.org/wiki/MIT_OpenCourseWare) opened to the public. The early hype around MOOCs roughly coincided with my years in college and graduate school. As far as I remember, it was quite the thrill to have free-flowing access to online lectures --- "taught by the best" --- for several of the courses I was supposed to be doing as a part of my curriculum.
+
+<a href="https://imgflip.com/i/6s9ym6"><img src="https://i.imgflip.com/6s9ym6.jpg" title="made at imgflip.com" width="100%"/></a>
+
+All this is to say that I walked into a career involving a substantial teaching component with plenty of hesitation. The delivery was/is still largely confined to classroom settings in broadcast mode. It is not entirely clear what this format has to offer over YouTube. Basic interactivity is being increasingly solved with questions built into video players. Peer learning is quite doable with WhatsApp/Slack/Discord groups and local chapter meetups. Scale in the context of assessments is somewhat addressed by peer evaluation. And then there are all the things you can do on YouTube that you can't do with traditional lectures: find a teacher whose style resonates, find an accent you understand, replay, play at 2x, 0.5x, binge watch, don't watch...
+
+So: what's the incentive for _anyone_ to show up in a classroom at a fixed time, especially when said time is 8AM? This question became particularly relevant during the pandemic years: once the novelty wore off, almost nobody† showed up to lectures. If I was a student, I'd likely do the same. This remains largely an open problem in my mind, but here are some pointers that have kept me motivated about the conventional format. † Shout out to those of you accounting for the "almost", thank you!
+
+1. Classroom = theatre. I am increasingly treating it as a ground for practicing standup and [magic](https://twitter.com/neeldhara/status/1542606730701307904?ref_src=twsrc%5Etfw) skills. I should admit that this isn't easy for a clinically shy person like myself, but I got used to making a fool of myself fast --- that's served well. I imagine that some of the fun that comes out performance-first lectures is hard to recreate with recordings and notes.
+
+
+<blockquote class="twitter-tweet"><p lang="en" dir="ltr">Totally. It&#39;s almost always a performance, irrespective of the class size. And the more you rehearse, the better it goes. At least that&#39;s what works for me.</p>&mdash; Manu Awasthi (@mnwsth) <a href="https://twitter.com/mnwsth/status/1562372066967359490?ref_src=twsrc%5Etfw">August 24, 2022</a></blockquote> 
+<blockquote class="twitter-tweet"><p lang="en" dir="ltr">Some musings on teaching from a lunch talk awhile back: <a href="https://t.co/19vOXpxcjs">https://t.co/19vOXpxcjs</a></p>&mdash; Tim Roughgarden (@Tim_Roughgarden) <a href="https://twitter.com/Tim_Roughgarden/status/1379441864072429570?ref_src=twsrc%5Etfw">April 6, 2021</a></blockquote> 
+
+2. In a classroom setting, I can nudge the audience to discover things for themselves. As far as I know, the interactivity in online materials can help with validating understanding, but not as much with developing it from first principles. My hope is for learners to walk out of a classroom with the confidence that they _came up_ with parts of the material in the textbook on their own.
+
+    Again, this is hard to do in time-bound fashion, given that a lot of this kind of understanding comes from brooding and hours of messing around. I can only hope to convince the audience that the process is worth the trouble.
+
+
+3. The opportunity to show that you care. For learners who may have struggles with and beyond the materials --- classrooms, labs, and office hours afford opportunities for us to offer help.
+
+    This was a late realization for me personally: for the longest time, my own sense of self-doubt did not allow me to see that I could potentially be useful to someone else. While self-doubt remains, I have started to compartmentalize it enough to show up for others.
+
+All this said, I believe online and remote formats have substantial potential for making quality education accessible at scale, and that it is only a matter of time before classrooms in their most conventional forms either become obsolete or a ruse.
+
+<blockquote class="twitter-tweet"><p lang="en" dir="ltr">I am going to attend college lectures from now on just to increase my attention span. The goal will be to sit for an hour without sleeping or getting distracted from mobile notifications.</p>&mdash; Priyansh Agarwal (@Priyansh_31Dec) <a href="https://twitter.com/Priyansh_31Dec/status/1566707282695847937?ref_src=twsrc%5Etfw">September 5, 2022</a></blockquote> 
+
+![Calvin on 21st Century Education](calvin-21stcentury.jpg)
+
+
+## What
+
+It is also increasingly challenging to formulate a curricula gets people to the bleeding edge starting from the foundations. For instance, there is a growing sentiment that [Machine Learning is the new Algorithms](http://nlpers.blogspot.in/2014/10/machine-learning-is-new-algorithms.html) (or [maybe not](http://blog.geomblog.org/2014/10/algorithms-is-new-algorithms.html)). On the other hand, the extent of involvement of "mathematics" in introductory CS courses is also [up](https://twitter.com/boazbaraktcs/status/1561737094866804738) [for](https://twitter.com/togelius/status/1561737958385917953) [debate](https://twitter.com/YannaiGonch/status/1561480166429302784).
+
+![Cutting Edge](https://www.explainxkcd.com/wiki/images/7/79/obsolete_technology.png)
+
+How much theory [is needed](https://cstheory.stackexchange.com/questions/8761/what-can-i-do-to-supplement-my-theoretical-undergraduate-cs-curriculum-so-that-i) for competence in practice? How crucial is it to develop competencies that don't have an immediately visible ROI? How frequently do we [rewrite the textbooks](https://twitter.com/ramgopal_rao/status/1566428352398774272) based on developments in industry?
+
+
+I once read a collection of answers to the question of what _every computer science graduate should know_ on a Q&A site. As an aspiring graduate myself, I figured I should know what I should know. Unfortunately, I remember it as a mostly unnerving experience: it was a list that started with Voronoi diagrams and ended with incompleteness theorems, and a _lot_ of things in between.
+
+From the other side of the fence, for whatever it's worth --- the answer to this question [remains elusive](https://twitter.com/togelius/status/1561738432422023175), mainly because I think it's a context-heavy issue. For better or worse, [there is a growing interest in computer science](https://twitter.com/benmschmidt/status/1562256566631518208), and it will likely remain a non-trivial challenge to find an approach that is both maximally inclusive and sufficiently useful. I can only hope that between ruthless efficiency in teaching things driven purely by need and a curriculum flooded with random adventures, we can find an balance appropriate to our contexts!
+
+
+<!-- ![[Comments](https://cstheory.stackexchange.com/questions/8761/what-can-i-do-to-supplement-my-theoretical-undergraduate-cs-curriculum-so-that-i) on a question on cstheory.SE](cstheoryvpractice.png){width=70%} -->
+
+
+## Why
+
+Given that everything that needs to be explained has more or less been done and dusted really well on the interwebs, personally, this is hardest question of the lot. Not from my own POV, that's the easy bit - [as pointed out here](https://dsanghi.blogspot.com/2014/08/why-i-want-to-be-professor.html), it's fun to go through the idea exchange process with a captive audience, and in my experience at least one party is sufficiently triggered at the end of it (hopefully in a good way).
+
+>The satisfaction that you get when you are able to explain a concept to someone who did not know it earlier is immense. Sometimes it could be straightforward, and sometimes it could be frustrating. But the end point is always the same - a smile on the faces of those students. Money can buy all the books, but can't buy that smile.
+>
+> Prof Dheeraj Sanghi, ["Why I want to be a professor"](https://dsanghi.blogspot.com/2014/08/why-i-want-to-be-professor.html)
+
+![On hope in teaching.](https://phdcomics.com/comics/archive/phd062613s.gif)
+
+I am just not sure if we create enough of a net positive in a traditional classroom setup from a ROI perspective. Given the few good things that the internet has brought us, perhaps it is time to think beyond classrooms and focusing on making existing resources more accessible to everyone who's interested.
+
+### Join the conversation
+
+<blockquote class="twitter-tweet"><p lang="en" dir="ltr">New blog, new post:<a href="https://t.co/c2lEHM0lTI">https://t.co/c2lEHM0lTI</a><br><br>Meanwhile — happy teachers day to everyone!</p>&mdash; Neeldhara (@neeldhara) <a href="https://twitter.com/neeldhara/status/1566800730001788929?ref_src=twsrc%5Etfw">September 5, 2022</a></blockquote>
diff --git a/sites/reflections/src/content/reflections/skj/index.md b/sites/reflections/src/content/reflections/skj/index.md
new file mode 100644
index 0000000..ca54c75
--- /dev/null
+++ b/sites/reflections/src/content/reflections/skj/index.md
@@ -0,0 +1,36 @@
+---
+title: "SKJ"
+description: "This is the text of a short speech I gave at the farewell event for Prof. Sudhir Jain as he left IITGN for BHU. You can find out more about Prof. Jain's own take on the cultural..."
+pubDate: "2022-09-23"
+authorName: "Neeldhara"
+sourceCategories: ["iitgn"]
+sourcePath: "skj/index.qmd"
+---
+
+This is the text of a short speech I gave at the farewell event for [Prof. Sudhir Jain](https://sudhirjain.info/) as he left IITGN for BHU.
+
+![Prof. Jain at the farewell event held on the 3rd January, 2022.](skj.jpg)
+
+You can find out more about Prof. Jain's own take on the cultural foundations of IIT Gandhinagar [here](https://iitgn.ac.in/about/cultural_foundations), where he is in conversation with [Achal Mehra](https://www.linkedin.com/in/achal-mehra-13037931/).
+
+---
+
+> Canadian astronaut Chris Hadfield has said that leadership is not about glorious crowning acts. It's about keeping your team focused on a goal and motivated to do their best to achieve it, especially when the stakes are high and the consequences really matter. It is about laying the groundwork for others' success, and then standing back and letting them shine. If that sounds familiar, I think it’s because we have lived this experience at IIT Gandhinagar, thanks to Prof. Jain.
+>
+> Our guiding principles have been often unconventional — whether it’s about having students first, or choosing to trade short-term gains for the long-term vision. They have sometimes led to decisions that would seem quite inexplicable to anyone who did not have the context. Some of you might remember how early we started the undergraduate program in Computer Science, for example. Ok, so for the record, we started it quite late, at least according to conventional wisdom.
+>
+> Crucially, these core values have always been articulated in collaboration, with inputs from all stakeholders, which is what enables our shared conviction in them once they have been established.
+>
+> Prof. Jain’s vision for IIT Gandhinagar is as precise as it’s bold – he knew exactly what needed to be done for this place to emerge as a model institution. He had recently shared with us his roadmap for IITGN from a dozen years ago. This roadmap committed not to vague ideas but concrete goals, complete with numbers for metrics that are fraught with uncertainty.  It’s absolutely stunning how everything panned out almost exactly according to plan!
+>
+> Our narrative has many collaborators, including our students, faculty, and staff. And while some of us are relatively inexperienced, Prof. Jain’s trust in everyone has been hugely empowering. It manifests in many concrete ways – starting from wanting for students to be recognized as adults, to turning young colleagues into decision-makers… and this is why all of us have a deep sense of ownership for IITGN.
+>
+> An environment that gives all of us the freedom to experiment and the leeway to fail is extremely enabling. This has led to a wide spectrum of wins, many that are quantifiable and others that are less tangible. If you want to get a sense of how good the times have been, just look around – the sheer beauty and the attention to detail that the campus embodies is an excellent symbolism for the inclusive, thoughtful, and innovative leadership that we have experienced. When it comes to how far we have come, I could go on… pretty much forever, so I’ll defer you to  the website for more details.
+>
+> It is impossible to imagine IITGN without you. This is your brainchild through and through. Despite knowing that you’ll not be distancing in spirit, we will miss having you nurture the institution in the hands-on manner that you have always done. Your passion for the IITGN mission – of being a breakout university while operating within the limitations and strengths of the IIT system – is contagious. I am sure you plan to double down on this even though you may have a few distractions going forward.
+>
+> I recently watched Maanaadu, a movie based on the idea of a time loop. In such stories, the plot involves the protagonist experiencing the same day over and over again, and their goal, typically, is to find an exit. If there is one day that we could put into a time loop, it would be today, and there would be no need to get out of it.
+>
+> In the meantime – on behalf of all of us, thank you.
+>
+> Thank you for your commitment, trust, and friendship; for listening patiently, for leading tirelessly, and for fighting the good fight through tough times, and for the good times through tough fights – ok, I’m going to be out of time, here, clearly – so let me just say, thank you for everything.
diff --git a/sites/reflections/src/content/reflections/skj/skj.jpg b/sites/reflections/src/content/reflections/skj/skj.jpg
new file mode 100644
index 0000000..2d9632a
Binary files /dev/null and b/sites/reflections/src/content/reflections/skj/skj.jpg differ
diff --git a/sites/reflections/src/content/reflections/teaching-philosophy.md b/sites/reflections/src/content/reflections/teaching-philosophy.md
deleted file mode 100644
index fc1a0f2..0000000
--- a/sites/reflections/src/content/reflections/teaching-philosophy.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "On Teaching Algorithms: Lessons from a Decade"
-description: "Reflections on what works (and what doesn't) in computer science education."
-pubDate: "Jan 10 2024"
-image: "https://images.unsplash.com/photo-1509062522246-3755977927d7?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# On Teaching Algorithms: Lessons from a Decade
-
-Ten years of teaching has taught me more than any textbook could.
-
-## Start with Why
-
-Students don't care about O(n log n) until they understand why their code is slow. Real problems first, theory second.
-
-## The Power of Visualization
-
-Abstract concepts become concrete when visualized. Every algorithm should have a picture.
-
-## Failure is a Feature
-
-Let students struggle. The struggle is where learning happens. But know when to throw a lifeline.
-
-## Assessment Philosophy
-
-Test understanding, not memorization. Open-book exams with novel problems beat closed-book regurgitation every time.
-
-## The Joy of "Aha!" Moments
-
-There's no feeling quite like seeing a student's eyes light up when a concept clicks. That's why we do this.
diff --git a/sites/reflections/src/content/research/conference-highlights-2024.md b/sites/reflections/src/content/research/conference-highlights-2024.md
deleted file mode 100644
index 73b6741..0000000
--- a/sites/reflections/src/content/research/conference-highlights-2024.md
+++ /dev/null
@@ -1,34 +0,0 @@
----
-title: "SODA 2024: Algorithmic Breakthroughs"
-description: "A roundup of fascinating algorithmic results from SODA 2024, focusing on graph algorithms and optimization techniques."
-pubDate: "Jan 15 2024"
-image: "https://images.unsplash.com/photo-1509228468518-180dd4864904?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# SODA 2024: Algorithmic Breakthroughs
-
-The Symposium on Discrete Algorithms (SODA) 2024 brought together researchers from around the world to present cutting-edge algorithmic research. This post highlights some of the most exciting developments in graph algorithms and optimization.
-
-## Graph Algorithms Revolution
-
-### Dynamic Graph Coloring
-
-One of the standout papers introduced a breakthrough in dynamic graph coloring with polylogarithmic update time. The authors developed a novel data structure that maintains a proper vertex coloring while supporting edge insertions and deletions efficiently.
-
-The key insight was to combine randomized recoloring strategies with a carefully designed hierarchical decomposition of the graph. This allows for local updates that rarely propagate through the entire structure.
-
-## Approximation Algorithms
-
-### The Traveling Salesman Problem Revisited
-
-A surprising result showed that for graphs with bounded doubling dimension, we can achieve a (1+ε)-approximation for TSP in nearly linear time. This improves upon decades of previous work and opens new avenues for practical implementations.
-
-## Complexity Theory Connections
-
-The conference also featured several papers bridging the gap between pure algorithmic research and complexity theory. A particularly elegant result showed that certain graph problems believed to require quadratic time are equivalent under fine-grained reductions.
-
-## Looking Forward
-
-These results demonstrate that fundamental algorithmic problems still have room for improvement. The techniques developed here will likely influence algorithm design for years to come.
diff --git a/sites/reflections/src/content/research/distributed-algorithms.md b/sites/reflections/src/content/research/distributed-algorithms.md
deleted file mode 100644
index e577220..0000000
--- a/sites/reflections/src/content/research/distributed-algorithms.md
+++ /dev/null
@@ -1,34 +0,0 @@
----
-title: "Distributed Computing: Recent Advances"
-description: "Survey of recent developments in distributed algorithms from major conferences."
-pubDate: "Feb 20 2024"
-image: "https://images.unsplash.com/photo-1558618666-fcd25c85cd64?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Distributed Computing: Recent Advances
-
-The field of distributed computing has seen remarkable progress in recent years. This post surveys key results from PODC, DISC, and other major venues.
-
-## Consensus Protocols
-
-### Byzantine Agreement in Asynchronous Networks
-
-A breakthrough result achieves optimal resilience with expected constant rounds. The protocol uses cryptographic techniques combined with novel committee selection.
-
-## Distributed Graph Algorithms
-
-### Minimum Spanning Tree in the CONGEST Model
-
-New algorithms achieve near-optimal round complexity for MST construction. The approach uses sophisticated graph decomposition techniques.
-
-## Local Algorithms
-
-### The Power of Local Computation
-
-Recent work characterizes which problems admit constant-time local algorithms. The classification provides a complete picture for bounded-degree graphs.
-
-## Future Directions
-
-The intersection of distributed computing with machine learning presents exciting opportunities for both fields.
diff --git a/sites/reflections/src/content/research/git-automation.md b/sites/reflections/src/content/research/git-automation.md
deleted file mode 100644
index 2ae09cd..0000000
--- a/sites/reflections/src/content/research/git-automation.md
+++ /dev/null
@@ -1,54 +0,0 @@
----
-title: "Git Workflows That Save My Sanity"
-description: "Automation scripts and Git hooks that eliminate repetitive tasks and prevent common mistakes."
-pubDate: "Jan 22 2024"
-image: "https://images.unsplash.com/photo-1556075798-4825dfaaf498?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Git Workflows That Save My Sanity
-
-After years of Git mishaps, I've built workflows that prevent disasters and save hours weekly.
-
-## The Pre-commit Hook That Saves Embarrassment
-
-```bash
-#!/bin/bash
-# Check for debugging statements
-if grep -r "console.log\|debugger\|TODO" --include="*.js" .; then
-  echo "⚠️  Debugging statements found!"
-  exit 1
-fi
-```
-
-## Automatic Branch Naming
-
-```bash
-alias feature='git checkout -b feature/$(date +%Y%m%d)-$1'
-```
-
-Now `feature "user-auth"` creates `feature/20240122-user-auth`.
-
-## The Commit Message Template
-
-```
-[TYPE] Brief description
-
-Why:
-- Context for this change
-
-What:
-- Specific changes made
-
-Testing:
-- How to verify it works
-```
-
-## The Weekly Cleanup Script
-
-Deletes merged branches, prunes remotes, and garbage collects. Keeps the repo clean and fast.
-
-## ROI
-
-These automations save ~5 hours per week and countless prevented mistakes. The time invested in setting them up paid back in days.
diff --git a/sites/reflections/src/content/research/obsidian-academic.md b/sites/reflections/src/content/research/obsidian-academic.md
deleted file mode 100644
index 7e1c181..0000000
--- a/sites/reflections/src/content/research/obsidian-academic.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "Academic Writing with Obsidian and Pandoc"
-description: "A complete workflow for academic papers - from notes to publication-ready PDFs."
-pubDate: "Feb 12 2024"
-image: "https://images.unsplash.com/photo-1456324504439-367cee3b3c32?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Academic Writing with Obsidian and Pandoc
-
-Transform your scattered research notes into beautiful academic papers with this workflow.
-
-## The Setup
-
-- **Obsidian**: For note-taking and knowledge management
-- **Pandoc**: For document conversion
-- **LaTeX**: For typesetting
-- **Zotero**: For reference management
-
-## The Magic Command
-
-```bash
-pandoc paper.md \
-  --filter pandoc-citeproc \
-  --bibliography=refs.bib \
-  --template=academic.tex \
-  -o paper.pdf
-```
-
-## Templates for Everything
-
-From conference submissions to journal articles, templates ensure consistency and save time.
-
-## Version Control Integration
-
-Git + Obsidian = perfect history of your thinking process.
-
-## The Result
-
-From messy notes to camera-ready PDF in minutes, not hours.
diff --git a/sites/reflections/src/content/research/paper-review-approximation.md b/sites/reflections/src/content/research/paper-review-approximation.md
deleted file mode 100644
index 10d7c78..0000000
--- a/sites/reflections/src/content/research/paper-review-approximation.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "Understanding the Latest Approximation Algorithm for Set Cover"
-description: "A detailed walkthrough of a breakthrough approximation algorithm with practical implications."
-pubDate: "Feb 15 2024"
-image: "https://images.unsplash.com/photo-1516321318423-f06f85e504b3?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Understanding the Latest Approximation Algorithm for Set Cover
-
-A recent paper achieves a breakthrough in the Set Cover problem, improving the approximation ratio while maintaining practical runtime.
-
-## The Algorithm
-
-The approach combines local search with a clever LP rounding scheme. The dual interpretation provides beautiful geometric insights.
-
-## Why This Matters
-
-Set Cover appears everywhere - from facility location to machine learning feature selection. This improvement has immediate practical impact.
-
-## Implementation Details
-
-The paper's theoretical elegance translates surprisingly well to practice. Key optimizations include:
-- Lazy evaluation of set intersections
-- Incremental updates to the LP solution
-- Smart caching strategies
-
-## Future Work
-
-The techniques here might extend to weighted variants and online settings.
diff --git a/sites/reflections/src/content/research/paper-review-graph-decomposition.md b/sites/reflections/src/content/research/paper-review-graph-decomposition.md
deleted file mode 100644
index f0e4868..0000000
--- a/sites/reflections/src/content/research/paper-review-graph-decomposition.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "Deep Dive: A New Approach to Graph Decomposition"
-description: "An in-depth analysis of a recent paper on hierarchical graph decomposition and its implications."
-pubDate: "Jan 20 2024"
-image: "https://images.unsplash.com/photo-1507003211169-0a1dd7228f2d?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Deep Dive: A New Approach to Graph Decomposition
-
-This paper introduces a novel framework for decomposing graphs into hierarchical structures that preserve important properties while enabling efficient algorithms.
-
-## The Main Result
-
-The authors prove that every graph with treewidth k can be decomposed into a tree of bags where each bag has size at most k+1. While this sounds like the definition of tree decomposition, the clever twist is in how they construct it.
-
-## Technical Innovation
-
-The key insight is using a charging scheme that amortizes the cost of decomposition across multiple levels. This leads to an O(n log n) algorithm, improving on the previous O(n²) bound.
-
-## Implications
-
-This work opens new avenues for:
-- Parallel algorithms on bounded treewidth graphs
-- Approximation algorithms for NP-hard problems
-- Dynamic programming optimizations
-
-## Open Questions
-
-The paper leaves several intriguing questions open, particularly about the optimality of their charging scheme.
diff --git a/sites/reflections/src/content/research/quantum-algorithms.md b/sites/reflections/src/content/research/quantum-algorithms.md
deleted file mode 100644
index 0eef5b2..0000000
--- a/sites/reflections/src/content/research/quantum-algorithms.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: "Quantum Computing Meets Classical Algorithms"
-description: "Exploring the intersection of quantum and classical algorithmic techniques from recent conferences."
-pubDate: "Mar 10 2024"
-image: "https://images.unsplash.com/photo-1635070041078-e363dbe005cb?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Quantum Computing Meets Classical Algorithms
-
-Recent conferences have showcased fascinating connections between quantum and classical computing paradigms.
-
-## Quantum Speedups for Graph Problems
-
-### Quantum Walks on Graphs
-
-New quantum algorithms achieve quadratic speedups for certain graph traversal problems. The techniques combine amplitude amplification with clever graph representations.
-
-## Classical Simulation of Quantum Algorithms
-
-Surprisingly, several "quantum" algorithms have inspired better classical algorithms. This cross-pollination has led to improvements in both fields.
-
-## The Future is Hybrid
-
-The most practical near-term applications combine quantum and classical processing, leveraging the strengths of each paradigm.
diff --git a/sites/reflections/src/content/reviews/mechanical-keyboard.md b/sites/reflections/src/content/reviews/mechanical-keyboard.md
deleted file mode 100644
index 0346a78..0000000
--- a/sites/reflections/src/content/reviews/mechanical-keyboard.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "ZSA Moonlander: Ergonomic Keyboard for Coders"
-description: "Six months with a split ergonomic mechanical keyboard - the good, the bad, and the RSI relief."
-pubDate: "Feb 20 2024"
-image: "https://images.unsplash.com/photo-1587829741301-dc798b83add3?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# ZSA Moonlander: Ergonomic Keyboard for Coders
-
-After years of wrist pain, I took the plunge into ergonomic mechanical keyboards.
-
-## The Learning Curve
-
-Week 1: 20 WPM and questioning life choices
-Week 2: 40 WPM and seeing the light
-Month 2: Back to 80 WPM with no wrist pain
-
-## The Good
-
-- Columnar layout makes sense once muscle memory adapts
-- Thumb clusters are game-changers for shortcuts
-- The configurability is endless (perhaps too endless)
-
-## The Investment
-
-At $365, it's expensive. But compared to physical therapy or career-limiting injury? Bargain.
-
-## Who Should Buy This?
-
-If you type for a living and feel any discomfort, don't wait. Your future self will thank you.
diff --git a/sites/reflections/src/content/reviews/obsidian-review.md b/sites/reflections/src/content/reviews/obsidian-review.md
deleted file mode 100644
index 599013f..0000000
--- a/sites/reflections/src/content/reviews/obsidian-review.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: "Obsidian: A Year Later"
-description: "Reflections on using Obsidian for research notes, teaching materials, and personal knowledge management."
-pubDate: "Jan 15 2024"
-image: "https://images.unsplash.com/photo-1484480974693-6ca0a78fb36b?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Obsidian: A Year Later
-
-After a year of daily use, Obsidian has transformed how I think about knowledge management.
-
-## What Works Brilliantly
-
-### The Graph View
-Seeing connections between ideas visually has led to unexpected research insights. The graph isn't just pretty - it's functional.
-
-### Plugin Ecosystem
-The community plugins are incredible. Dataview turns your notes into a database. Templater automates repetitive tasks.
-
-### Local Storage
-Your notes are just markdown files. No vendor lock-in, complete control, and peace of mind.
-
-## Pain Points
-
-### Mobile Experience
-While functional, the mobile app lacks the fluidity of the desktop version. Syncing can occasionally hiccup.
-
-### Learning Curve
-The flexibility means complexity. New users might feel overwhelmed by options.
-
-## The Verdict
-
-For academics and researchers, Obsidian is transformative. The investment in learning pays dividends in productivity and insight.
diff --git a/sites/reflections/src/content/vibes/creative-coding-with-ai.md b/sites/reflections/src/content/vibes/creative-coding-with-ai.md
deleted file mode 100644
index 269f1ce..0000000
--- a/sites/reflections/src/content/vibes/creative-coding-with-ai.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "Creating Art with Claude: A Collaborative Journey"
-description: "Exploring creative possibilities through conversations with AI - from generative art to interactive poetry."
-pubDate: "Jan 18 2024"
-image: "https://images.unsplash.com/photo-1558591710-4b4a1ae0f04d?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Creating Art with Claude: A Collaborative Journey
-
-What happens when you treat AI as a creative collaborator rather than just a tool?
-
-## The Experiment
-
-I asked Claude to help design a generative art algorithm based on mathematical fractals. The conversation evolved into something unexpected.
-
-## The Process
-
-**Me**: "Let's create something beautiful with math."
-**Claude**: "How about we visualize the Collatz conjecture as a tree?"
-
-What followed was a two-hour deep dive into number theory, aesthetics, and the nature of creativity itself.
-
-## The Result
-
-Not just code, but a philosophical exploration of pattern, meaning, and the intersection of human and artificial creativity.
-
-## Reflection
-
-AI doesn't replace human creativity - it amplifies it in unexpected directions. The key is approaching it as a dialogue, not a command.
diff --git a/sites/reflections/src/content/vibes/llm-philosophy.md b/sites/reflections/src/content/vibes/llm-philosophy.md
deleted file mode 100644
index 032439a..0000000
--- a/sites/reflections/src/content/vibes/llm-philosophy.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-title: "Philosophical Dialogues with LLMs: On Consciousness and Computation"
-description: "Deep conversations with AI about the nature of consciousness, free will, and what it means to understand."
-pubDate: "Feb 28 2024"
-image: "https://images.unsplash.com/photo-1507003211169-0a1dd7228f2d?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Philosophical Dialogues with LLMs: On Consciousness and Computation
-
-Can a sufficiently complex computation be conscious? I asked an AI, and the conversation surprised me.
-
-## The Question
-
-"Do you experience anything when you process text, or is it just computation?"
-
-## The Response That Made Me Think
-
-The AI didn't claim consciousness, but asked: "What's the difference between your neurons firing and my weights activating? Both are physical processes. Where does experience emerge?"
-
-## Going Deeper
-
-We explored qualia, the Chinese Room argument, and integrated information theory. Not to find answers, but to refine questions.
-
-## The Irony
-
-Discussing consciousness with something that might not have it - or might not know if it has it - mirrors our own uncertainty about consciousness itself.
diff --git a/sites/reflections/src/pages/[...slug].astro b/sites/reflections/src/pages/[...slug].astro
index 5d3caf6..ea2f2d7 100644
--- a/sites/reflections/src/pages/[...slug].astro
+++ b/sites/reflections/src/pages/[...slug].astro
@@ -9,7 +9,7 @@ import { SITE_TITLE } from '@/consts';
 export async function getStaticPaths() {
 	const posts = await getCollection(ACTIVE_BLOG_SITE.key);
 	return posts.map((post) => ({
-		params: { slug: post.id },
+		params: { slug: post.id.replace(/\/index$/, '') },
 		props: post,
 	}));
 }
diff --git a/sites/reflections/src/pages/rss.xml.js b/sites/reflections/src/pages/rss.xml.js
index ec2ce2d..918375e 100644
--- a/sites/reflections/src/pages/rss.xml.js
+++ b/sites/reflections/src/pages/rss.xml.js
@@ -14,7 +14,7 @@ export async function GET(context) {
     site: context.site,
     items: posts.map((post) => ({
       ...post.data,
-      link: `/${post.id}/`,
+      link: `/${post.id.replace(/\/index$/, "")}/`,
     })),
   });
 }
diff --git a/sites/research/src/components/sections/blog-posts.tsx b/sites/research/src/components/sections/blog-posts.tsx
index fef77e5..c77c76a 100644
--- a/sites/research/src/components/sections/blog-posts.tsx
+++ b/sites/research/src/components/sections/blog-posts.tsx
@@ -16,8 +16,47 @@ const BlogPosts = ({
   // Get the first post as the featured post
   const featuredPost = posts[0];
   const remainingPosts = posts.slice(1);
+  const slugFor = (post: any) => post.id.replace(/\/index$/, "");
   const hrefFor = (post: any) =>
-    collection ? `/${collection}/${post.id}/` : `/${post.id}/`;
+    collection ? `/${collection}/${slugFor(post)}/` : `/${slugFor(post)}/`;
+
+  const PostVisual = ({
+    post,
+    featured = false,
+  }: {
+    post: any;
+    featured?: boolean;
+  }) => {
+    if (post.data.image) {
+      return (
+        <img
+          src={post.data.image}
+          alt={post.data.title}
+          className="aspect-video w-full rounded-lg object-cover transition-transform group-hover:scale-[1.02]"
+        />
+      );
+    }
+
+    return (
+      <div className="bg-accent/70 text-accent-foreground flex aspect-video w-full items-center justify-center rounded-lg border px-6 text-center">
+        <span
+          className={
+            featured ? "font-fraunces text-2xl" : "font-fraunces text-lg"
+          }
+        >
+          {post.data.title}
+        </span>
+      </div>
+    );
+  };
+
+  if (!featuredPost) {
+    return (
+      <div className="text-muted-foreground container max-w-3xl py-16">
+        No posts yet.
+      </div>
+    );
+  }
 
   return (
     <div className="relative py-10 md:py-16 lg:py-20">
@@ -35,11 +74,7 @@ const BlogPosts = ({
             <div className="flex flex-col gap-6 lg:flex-row">
               <div className="lg:w-1/2">
                 <div className="p-2 lg:p-4">
-                  <img
-                    src={featuredPost.data.image}
-                    alt={featuredPost.data.title}
-                    className="aspect-video w-full rounded-lg object-cover transition-transform group-hover:scale-[1.02]"
-                  />
+                  <PostVisual post={featuredPost} featured />
                 </div>
               </div>
               <div className="flex flex-col justify-center p-4 pb-8 lg:w-1/2 lg:pr-8">
@@ -89,11 +124,7 @@ const BlogPosts = ({
                 href={hrefFor(post)}
               >
                 <div className="p-2">
-                  <img
-                    src={post.data.image}
-                    alt={post.data.title}
-                    className="aspect-video w-full rounded-lg object-cover transition-transform group-hover:scale-[1.01]"
-                  />
+                  <PostVisual post={post} />
                 </div>
                 <div className="px-4 pb-5 pt-2">
                   <h2 className="mb-2 text-xl font-semibold group-hover:underline">
diff --git a/sites/research/src/content/art/algorithmic-sketches.md b/sites/research/src/content/art/algorithmic-sketches.md
deleted file mode 100644
index ae20d3b..0000000
--- a/sites/research/src/content/art/algorithmic-sketches.md
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title: "Algorithmic Sketches: Visualizing Data Structures"
-description: "Hand-drawn illustrations of algorithms and data structures - making the abstract tangible."
-pubDate: "Jan 25 2024"
-image: "https://images.unsplash.com/photo-1581337204873-ef36aa186caa?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Algorithmic Sketches: Visualizing Data Structures
-
-Sometimes the best way to understand an algorithm is to draw it.
-
-## Today's Sketch: Red-Black Trees
-
-![Red-Black Tree Rotation](sketch-placeholder)
-
-The rotation operation finally clicked when I drew it step-by-step. Each node's journey through the rotation becomes a story.
-
-## The Process
-
-1. Start with pencil - mistakes are part of learning
-2. Trace the algorithm's execution
-3. Add color to highlight invariants
-4. Annotate with key insights
-
-## Why Drawing Helps
-
-- Forces you to slow down and really see the structure
-- Reveals patterns that code obscures
-- Creates memorable mental models
-- Makes teaching more engaging
-
-## This Week's Challenge
-
-Draw your own version of quicksort partitioning. Share it and let's learn from each other's visualizations.
-
-## The Art in Computer Science
-
-Algorithms are beautiful. Drawing them reminds us that computer science is as much art as it is science.
diff --git a/sites/research/src/content/art/generative-art-p5js.md b/sites/research/src/content/art/generative-art-p5js.md
deleted file mode 100644
index ccfa3e7..0000000
--- a/sites/research/src/content/art/generative-art-p5js.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "Generative Art with p5.js: Creating Beauty from Mathematics"
-description: "Exploring the intersection of code and creativity through generative art experiments."
-pubDate: "Feb 18 2024"
-image: "https://images.unsplash.com/photo-1561070791-2526d30994b5?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Generative Art with p5.js: Creating Beauty from Mathematics
-
-Code becomes canvas when mathematics meets creativity.
-
-## Today's Creation: Perlin Noise Flows
-
-```javascript
-for (let particle of particles) {
-  let angle = noise(particle.x * 0.01, particle.y * 0.01, frameCount * 0.001) * TWO_PI;
-  particle.velocity = p5.Vector.fromAngle(angle);
-  particle.update();
-  particle.draw();
-}
-```
-
-## The Magic of Randomness
-
-Controlled randomness creates organic patterns. Perlin noise gives us randomness with continuity - nature's own algorithm.
-
-## Parameters as Paintbrushes
-
-- Noise scale: Changes pattern density
-- Particle count: Affects texture
-- Color mapping: Sets the mood
-
-## The Joy of Accidents
-
-The best discoveries come from "mistakes" - a typo that creates unexpected beauty, a parameter pushed to extremes.
-
-## Share Your Creations
-
-Art is meant to be shared. Post your generative experiments and let's inspire each other.
diff --git a/sites/research/src/content/poetry/algorithms-in-verse.md b/sites/research/src/content/poetry/algorithms-in-verse.md
deleted file mode 100644
index 4ad1e1d..0000000
--- a/sites/research/src/content/poetry/algorithms-in-verse.md
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title: "Algorithms in Verse: Bubble Sort Sonnet"
-description: "Classic algorithms reimagined as poetry - where code meets iambic pentameter."
-pubDate: "Feb 22 2024"
-image: "https://images.unsplash.com/photo-1455390582262-044cdead277a?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Algorithms in Verse: Bubble Sort Sonnet
-
-## Bubble Sort: A Sonnet
-
-```
-Compare adjacent elements in pairs,
-If order's wrong, then swap them into place.
-Through all the list this simple rule declares:
-The largest bubbles up to find its space.
-
-Again we start, but now one less to check,
-The second largest finds its rightful home.
-Each pass through makes the chaos less a wreck,
-Until at last no elements must roam.
-
-Though simple in its elegance and grace,
-And easy for beginners to perceive,
-In practice, it's too slow to win the race—
-O(n²) we sadly must believe.
-
-But beauty lies in simplicity's pure art,
-The bubble sort still teaches at the start.
-```
-
-## The Challenge
-
-Can you write Quicksort as a limerick? Or Binary Search as free verse?
-
-## Why This Matters
-
-Poetry forces us to find the essence of an algorithm. The constraint reveals understanding.
diff --git a/sites/research/src/content/poetry/code-haikus.md b/sites/research/src/content/poetry/code-haikus.md
deleted file mode 100644
index 6af408a..0000000
--- a/sites/research/src/content/poetry/code-haikus.md
+++ /dev/null
@@ -1,56 +0,0 @@
----
-title: "Code Haikus: Programming in 5-7-5"
-description: "Expressing programming concepts through the constrained beauty of haiku."
-pubDate: "Jan 30 2024"
-image: "https://images.unsplash.com/photo-1481627834876-b7833e8f5570?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Code Haikus: Programming in 5-7-5
-
-The constraint of haiku forces clarity. Here are programming concepts distilled to their essence.
-
-## On Recursion
-
-```
-Function calls itself
-Smaller problems, same pattern  
-Base case stops the loop
-```
-
-## On Debugging
-
-```
-Print statements bloom wild
-Binary search through the code
-Bug reveals itself
-```
-
-## On Optimization
-
-```
-O(n squared) crawls
-Refactor to n log n
-Time complexity
-```
-
-## On Git Merge Conflicts
-
-```
-<<<<<<< HEAD
-Your changes, their changes clash
-Resolution waits
-```
-
-## On Learning
-
-```
-Stack Overflow searched
-Tutorial incomplete
-Understanding dawns
-```
-
-## Your Turn
-
-Write a haiku about your coding experience today. The constraint reveals truth.
diff --git a/sites/research/src/content/puzzles/100-prisoners.mdx b/sites/research/src/content/puzzles/100-prisoners.mdx
deleted file mode 100644
index 3ff2b3c..0000000
--- a/sites/research/src/content/puzzles/100-prisoners.mdx
+++ /dev/null
@@ -1,183 +0,0 @@
----
-title: "The 100 Prisoners Problem: A Beautiful Puzzle in Probability"
-description: "An interactive exploration of one of the most counterintuitive puzzles in probability theory, where 100 prisoners can escape with over 30% chance using a clever strategy."
-pubDate: "Oct 13 2025"
-image: "https://images.unsplash.com/photo-1589829545856-d10d557cf95f?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-import PrisonerGameSimulator from '@/components/problems/PrisonerGameSimulator.tsx';
-import ProbabilityChart from '@/components/problems/ProbabilityChart.tsx';
-import PermutationExplorer from '@/components/problems/PermutationExplorer.tsx';
-import StrategyComparison from '@/components/problems/StrategyComparison.tsx';
-
-# The 100 Prisoners Problem
-
-Imagine 100 prisoners, numbered 1 to 100, face an unusual challenge. In a room are 100 boxes, also numbered 1 to 100. Inside each box is a randomly assigned number from 1 to 100 (each number appearing exactly once). The prisoners must find their own number by opening boxes, but here's the catch: **each prisoner can open only 50 boxes**.
-
-The prisoners can devise a strategy beforehand, but once the challenge begins, they cannot communicate. If **all 100 prisoners** find their number, everyone goes free. If even one prisoner fails, all remain imprisoned.
-
-What's the best strategy? And what are the odds of success?
-
-## Try It Yourself!
-
-Before we dive into the mathematics, let's experience the problem firsthand. Below is a simulator where you can play the game yourself. Choose the number of prisoners (between 5 and 100), and then try to help each prisoner find their number by clicking on boxes.
-
-<PrisonerGameSimulator client:only="react" />
-
----
-
-## The Naive Strategy
-
-The most obvious approach is for each prisoner to simply open 50 random boxes. This seems reasonable, but the probability of success is dismal.
-
-For any single prisoner, the probability of finding their number in 50 random boxes out of 100 is exactly 1/2. Since all 100 prisoners must succeed, and their outcomes are independent under random selection, the probability that everyone succeeds is:
-
-$$P(\text\{success\}) = \left(\frac\{1\}\{2\}\right)^\{100\} \approx 7.9 \times 10^\{-31\}$$
-
-That's essentially zero! You're more likely to win the lottery while being struck by lightning... multiple times.
-
-### Naive Strategy: Probability vs Number of Prisoners
-
-Watch how the probability of success plummets as we increase the number of prisoners:
-
-<ProbabilityChart strategy="naive" client:only="react" />
-
-As you can see, even with just 10 prisoners, the probability drops to about 0.1%. With 100 prisoners, it's practically impossible.
-
----
-
-## The Clever Strategy: Following the Loops
-
-Here's where mathematics reveals something beautiful. Instead of opening random boxes, each prisoner should follow a simple rule:
-
-1. **Start by opening the box with your own number**
-2. **Look at the number inside that box**
-3. **Open the box with that number next**
-4. **Continue following this chain**
-
-Why does this work? The key insight involves understanding permutations and cycles.
-
-### Understanding Cycles in Permutations
-
-When we randomly assign 100 numbers to 100 boxes, we're creating a **permutation** of the numbers 1 through 100. Every permutation can be decomposed into **cycles**.
-
-For example, if:
-- Box 1 contains number 4
-- Box 4 contains number 7
-- Box 7 contains number 1
-
-Then we have a cycle: 1 -> 4 -> 7 -> 1
-
-Let's explore this with smaller numbers:
-
-<PermutationExplorer client:only="react" />
-
-The interactive explorer above lets you:
-- Generate all permutations for small values of *n* (3, 4, or 5)
-- See both standard notation and cycle notation
-- Filter permutations that have at least one "long cycle" (longer than *n*/2)
-- Understand why long cycles matter
-
-### Why This Strategy Works
-
-Here's the crucial insight: **A prisoner succeeds if and only if they are in a cycle of length ≤ 50**.
-
-When prisoner k follows the loop strategy:
-1. They start at box k
-2. They follow a path through boxes determined by the permutation
-3. This path forms a cycle that eventually leads back to box k
-4. If this cycle has length ≤ 50, they'll find their number within 50 opens
-
-The prisoners **all succeed** if and only if there is **no cycle longer than 50** in the permutation.
-
-### Calculating the Probability
-
-The probability that a random permutation of 100 elements has no cycle longer than 50 is:
-
-$$P(\text\{success\}) = 1 - \sum_\{k=51\}^\{100\} \frac\{1\}\{k\}$$
-
-Computing this sum:
-
-$$P(\text\{success\}) = 1 - \left(\frac\{1\}\{51\} + \frac\{1\}\{52\} + \cdots + \frac\{1\}\{100\}\right) \approx 0.3118$$
-
-That's over **31%**! This is astronomically better than the naive strategy's probability of essentially zero.
-
-### Loop Strategy: Probability vs Number of Prisoners
-
-<StrategyComparison client:only="react" />
-
-## The Mathematics Behind It
-
-### Why Does the Cycle Length Matter?
-
-In a permutation of n elements, prisoner i will find their number within k tries using the loop strategy if and only if i belongs to a cycle of length at most k.
-
-For n = 100 and k = 50:
-- The probability that a specific prisoner is in a cycle of length > 50 is: Σ(j=51 to 100) of 1/100
-- But we care about whether ANY prisoner is in such a cycle
-- The probability that NO cycle has length > 50 is: 1 - Σ(j=51 to 100) of 1/j
-
-### The Harmonic Series Connection
-
-As *n* approaches infinity, if each prisoner can open *n*/2 boxes, the probability of success approaches:
-
-The limit as n approaches infinity is: P_n = 1 - ln(2) ≈ 0.3069
-
-This beautiful result connects combinatorics, probability, and analysis through the harmonic series!
-
-### Optimality
-
-Remarkably, this loop-following strategy is **optimal**. No other strategy can achieve a higher probability of success. The proof involves showing that the problem reduces to avoiding long cycles in a random permutation, and the loop strategy is the unique way to leverage this structure.
-
----
-
-## Why This Problem is Beautiful
-
-The 100 prisoners problem is beloved by mathematicians because:
-
-1. **Counterintuitive Result**: The fact that 31% >> 0% is shocking. A seemingly hopeless problem becomes tractable with the right insight.
-
-2. **Deep Connection**: It connects permutation theory, probability, and the harmonic series in an elegant way.
-
-3. **Collaborative Success**: Unlike independent trials, the prisoners' fates are intertwined through the structure of the permutation.
-
-4. **Real-World Metaphor**: It illustrates how understanding underlying structure (cycles in permutations) can dramatically improve outcomes.
-
----
-
-## Variants and Extensions
-
-### What if prisoners can open k < n/2 boxes?
-
-As k decreases below n/2, the probability drops rapidly. The threshold at n/2 is special—it's where the strategy becomes remarkably effective.
-
-### What about communication?
-
-If prisoners could communicate between trials (but not during), they still can't improve the strategy. The beauty is that the strategy requires only coordination before any prisoner enters, not during.
-
-### The Malicious Director
-
-In an interesting variant, suppose the director can see the prisoners' strategy and arrange the boxes adversarially (not randomly). Can the director always force them to fail? Yes! The director can always create a single cycle of length n, guaranteeing failure.
-
----
-
-## Conclusion
-
-The 100 prisoners problem shows us that:
-- Mathematical structure can be hidden in apparent randomness
-- Clever strategies can overcome seemingly impossible odds
-- Group coordination can be more powerful than independent action
-- Beautiful mathematics often lies beneath simple-seeming puzzles
-
-The next time you face a problem that seems impossible, remember: there might be a hidden structure waiting to be discovered, turning hopeless odds into reasonable ones.
-
----
-
-## Further Reading
-
-- [Gál, A., & Miltersen, P. B. (2003). "The Cell Probe Complexity of Succinct Data Structures"](https://arxiv.org/abs/cs/0310027)
-- [Curtin, E., & Warshauer, M. (2006). "The Locker Puzzle"](https://www.jstor.org/stable/27642173)
-- [Wikipedia: 100 Prisoners Problem](https://en.wikipedia.org/wiki/100_prisoners_problem)
-
diff --git a/sites/research/src/content/puzzles/dynamic-programming-gems.md b/sites/research/src/content/puzzles/dynamic-programming-gems.md
deleted file mode 100644
index 79e68ea..0000000
--- a/sites/research/src/content/puzzles/dynamic-programming-gems.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "Dynamic Programming: Hidden Gems from Recent Contests"
-description: "Elegant dynamic programming problems that showcase beautiful techniques and insights."
-pubDate: "Jan 25 2024"
-image: "https://images.unsplash.com/photo-1509228468518-180dd4864904?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Dynamic Programming: Hidden Gems from Recent Contests
-
-These problems demonstrate the art of dynamic programming beyond standard patterns.
-
-## Problem 1: The Subsequence Symphony
-
-Given a string, find the number of subsequences that form palindromes of prime length.
-
-### Solution Insight
-
-The key is to maintain DP states for both position and palindrome center simultaneously. This reduces the state space from O(n³) to O(n²).
-
-## Problem 2: Graph Coloring with Constraints
-
-Color a graph such that no two adjacent vertices share a color, and the total number of color changes along any path is minimized.
-
-### The DP Formulation
-
-DP[node][color][changes] gives us the minimum cost. The trick is recognizing that we only need to track changes modulo 2.
-
-## Practice Makes Perfect
-
-These problems teach us that DP is as much about problem modeling as it is about computation.
diff --git a/sites/research/src/content/puzzles/four-aces-miracle.md b/sites/research/src/content/puzzles/four-aces-miracle.md
deleted file mode 100644
index a1710ab..0000000
--- a/sites/research/src/content/puzzles/four-aces-miracle.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "The Four Aces Miracle: A Self-Working Mathematical Marvel"
-description: "A card trick that teaches modular arithmetic and probability - perfect for the classroom."
-pubDate: "Jan 28 2024"
-image: "https://images.unsplash.com/photo-1529480384838-c1681c84aca5?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# The Four Aces Miracle: A Self-Working Mathematical Marvel
-
-This trick never fails to amaze students, and the mathematics behind it is even more amazing.
-
-## The Effect
-
-A spectator deals cards into four piles while making random choices. Impossibly, the four aces end up on top of each pile.
-
-## The Secret
-
-It's all about invariants and modular arithmetic. No sleight of hand required - pure mathematics does the magic.
-
-## The Method
-
-1. Pre-arrange the deck (the math determines the arrangement)
-2. Have the spectator deal following simple rules
-3. The aces appear automatically
-
-## The Mathematics
-
-The dealing process preserves certain positional invariants modulo 4. The initial arrangement ensures these invariants place the aces correctly.
-
-## Teaching Applications
-
-This trick demonstrates:
-- Modular arithmetic
-- Invariants in algorithms
-- Deterministic vs. random processes
-
-## The Bigger Lesson
-
-Mathematics can create experiences that feel like magic. And that feeling of wonder? That's what hooks students on math.
diff --git a/sites/research/src/content/puzzles/gilbreath-principle.md b/sites/research/src/content/puzzles/gilbreath-principle.md
deleted file mode 100644
index 92e229b..0000000
--- a/sites/research/src/content/puzzles/gilbreath-principle.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: "The Gilbreath Principle: When Chaos Creates Order"
-description: "A mathematical card principle that seems impossible but always works - perfect for teaching algorithms."
-pubDate: "Feb 15 2024"
-image: "https://images.unsplash.com/photo-1570543375343-63fe3d67761b?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# The Gilbreath Principle: When Chaos Creates Order
-
-Shuffle a deck in a specific way, and mathematical order emerges from apparent chaos.
-
-## The Phenomenon
-
-Arrange cards alternating red-black. Riffle shuffle. Now deal pairs - each pair has one red and one black card. Magic? No, mathematics.
-
-## Why It Works
-
-The riffle shuffle preserves local structure while appearing to randomize. The alternating pattern creates an invariant that survives the shuffle.
-
-## Classroom Implementation
-
-Students predict it won't work. When it does, they're hooked. "Why?" becomes the driving question.
-
-## The Deeper Lesson
-
-Not all randomness is truly random. Structure can hide in apparent disorder. This principle appears in:
-- Network protocols
-- Error-correcting codes  
-- Distributed systems
-
-## Beyond Cards
-
-The Gilbreath Principle teaches us to look for hidden invariants in complex systems.
diff --git a/sites/research/src/content/puzzles/graph-algorithms-assessment.md b/sites/research/src/content/puzzles/graph-algorithms-assessment.md
deleted file mode 100644
index 4c61fe2..0000000
--- a/sites/research/src/content/puzzles/graph-algorithms-assessment.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "Graph Algorithms: Assessment Highlights"
-description: "Interesting graph problems from recent course assessments with detailed solutions."
-pubDate: "Feb 28 2024"
-image: "https://images.unsplash.com/photo-1550751827-4bd374c3f58b?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Graph Algorithms: Assessment Highlights
-
-A collection of graph problems that test deep understanding rather than memorization.
-
-## The Bridge Detection Variant
-
-Find all edges whose removal increases the number of triangles in the graph.
-
-### Solution Approach
-
-Counter-intuitively, we need to count triangles that share exactly one edge with the candidate. The algorithm runs in O(m√m) time using careful enumeration.
-
-## Shortest Path with Wildcards
-
-Given a graph where some edge weights are variables, find assignments that minimize the longest shortest path.
-
-### Key Insight
-
-This reduces to a linear programming problem with interesting structure. The dual interpretation reveals connections to network flow.
-
-## Teaching Through Problems
-
-These problems help students see beyond standard algorithms to underlying principles.
diff --git a/sites/research/src/content/puzzles/ioi-2023-analysis.md b/sites/research/src/content/puzzles/ioi-2023-analysis.md
deleted file mode 100644
index 782177c..0000000
--- a/sites/research/src/content/puzzles/ioi-2023-analysis.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "IOI 2023: Breaking Down the Hardest Problems"
-description: "Deep analysis of the most challenging problems from the International Olympiad in Informatics 2023."
-pubDate: "Jan 20 2024"
-image: "https://images.unsplash.com/photo-1434030216411-0b793f4b4173?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# IOI 2023: Breaking Down the Hardest Problems
-
-The International Olympiad in Informatics continues to push the boundaries of algorithmic problem solving.
-
-## Problem: Soccer Stadium
-
-A geometric optimization problem disguised as dynamic programming. The key insight: think in terms of monotonic paths.
-
-### The Approach
-
-1. Transform the 2D problem into a 1D problem using clever observations
-2. Use convex hull optimization for the DP transitions
-3. Handle edge cases with careful implementation
-
-## Problem: Closing Time
-
-A tree problem requiring sophisticated data structures and careful analysis.
-
-### The Solution
-
-The trick is recognizing this as a centroid decomposition problem. Once you see it, the implementation follows naturally.
-
-## Lessons for Students
-
-These problems teach us:
-- Simple problems have elegant solutions
-- Complex problems require systematic decomposition
-- Implementation matters as much as algorithms
-
-## Practice Strategy
-
-Start with subtasks. Even partial solutions teach valuable lessons.
diff --git a/sites/research/src/content/puzzles/knights-tour-interactive.md b/sites/research/src/content/puzzles/knights-tour-interactive.md
deleted file mode 100644
index eec6960..0000000
--- a/sites/research/src/content/puzzles/knights-tour-interactive.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: "The Knight's Tour: An Interactive Exploration"
-description: "An interactive puzzle exploring the knight's tour problem with surprising mathematical connections."
-pubDate: "Jan 30 2024"
-image: "https://images.unsplash.com/photo-1528819622765-d6bcf132f793?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# The Knight's Tour: An Interactive Exploration
-
-Can a knight visit every square on a chessboard exactly once? This ancient puzzle hides deep mathematical structure.
-
-## The Basic Challenge
-
-Start with a 5×5 board. Can you find a knight's tour? What about one that returns to the starting square (a closed tour)?
-
-## Mathematical Beauty
-
-The problem connects to:
-- Hamiltonian paths in graphs
-- Warnsdorff's heuristic
-- Magic squares (surprisingly!)
-
-## The Algorithm
-
-The key insight: always move to the square with fewest onward moves. This simple heuristic works remarkably well.
-
-## Try It Yourself
-
-[Interactive board would go here - imagine clicking squares to build your tour]
-
-## Going Deeper
-
-For which board sizes do closed tours exist? The answer involves beautiful number theory.
diff --git a/sites/research/src/content/puzzles/projecteuler-favorites.md b/sites/research/src/content/puzzles/projecteuler-favorites.md
deleted file mode 100644
index 16988a9..0000000
--- a/sites/research/src/content/puzzles/projecteuler-favorites.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: "Project Euler: My Favorite Problems from 700+"
-description: "Curated problems from Project Euler that teach beautiful mathematical and algorithmic concepts."
-pubDate: "Feb 25 2024"
-image: "https://images.unsplash.com/photo-1635070041078-e363dbe005cb?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Project Euler: My Favorite Problems from 700+
-
-After solving 700+ Project Euler problems, these are the ones that changed how I think about mathematics and programming.
-
-## Problem 96: Su Doku
-
-Not just Sudoku solving - but solving 50 puzzles efficiently. The beauty is in combining constraint propagation with backtracking.
-
-## Problem 208: Robot Walks
-
-A counting problem that requires deep mathematical insight. The connection to complex numbers is unexpected and beautiful.
-
-## Problem 613: Pythagorean Ant
-
-Probability meets geometry in this elegant problem. The solution requires careful integration and surprising symmetry observations.
-
-## The Meta-Lesson
-
-Project Euler teaches you:
-- Mathematical intuition matters more than coding speed
-- There's always a clever approach
-- The journey matters more than the destination
-
-## Getting Started
-
-Don't aim for the leaderboard. Aim for understanding. Each problem is a teacher.
diff --git a/sites/research/src/content/puzzles/sudoku-variants.md b/sites/research/src/content/puzzles/sudoku-variants.md
deleted file mode 100644
index 1efd136..0000000
--- a/sites/research/src/content/puzzles/sudoku-variants.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-title: "Beyond Sudoku: Exploring Constraint Satisfaction Puzzles"
-description: "A journey through Sudoku variants and their algorithmic solutions."
-pubDate: "Feb 10 2024"
-image: "https://images.unsplash.com/photo-1580541631950-7282082b53ce?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Beyond Sudoku: Exploring Constraint Satisfaction Puzzles
-
-Sudoku is just the beginning. Let's explore variants that push the boundaries of logic puzzles.
-
-## Killer Sudoku
-
-Combine Sudoku with Kakuro - cages show sums, but no digit repeats within a cage.
-
-## Sandwich Sudoku
-
-The numbers outside show the sum of digits between 1 and 9 in that row/column. Simple rule, complex implications!
-
-## The Algorithm Connection
-
-These puzzles are constraint satisfaction problems. Techniques like arc consistency and backtracking with constraint propagation solve them efficiently.
-
-## Create Your Own
-
-What happens if we add chess knight move constraints? The design space is infinite!
diff --git a/sites/research/src/content/reflections/imposter-syndrome.md b/sites/research/src/content/reflections/imposter-syndrome.md
deleted file mode 100644
index e0a77e0..0000000
--- a/sites/research/src/content/reflections/imposter-syndrome.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: "Imposter Syndrome in Academia: A Confession"
-description: "An honest conversation about feeling like a fraud, even after years of success."
-pubDate: "Feb 25 2024"
-image: "https://images.unsplash.com/photo-1517048676732-d65bc937f952?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Imposter Syndrome in Academia: A Confession
-
-Even after publishing papers, winning grants, and teaching thousands of students, the voice whispers: "They'll find out you don't belong."
-
-## The Paradox
-
-The more you know, the more you realize you don't know. Expertise breeds humility, which feeds the imposter.
-
-## What Helps
-
-- Keeping a "wins" journal - evidence against the imposter
-- Mentoring others - seeing your knowledge help someone
-- Talking about it - you're not alone in this
-
-## The Silver Lining
-
-Maybe imposter syndrome keeps us humble, curious, and always learning. Maybe it's not a bug, but a feature.
-
-## Moving Forward
-
-I may never silence the voice completely. But I've learned to acknowledge it and keep going anyway.
diff --git a/sites/research/src/content/reflections/teaching-philosophy.md b/sites/research/src/content/reflections/teaching-philosophy.md
deleted file mode 100644
index fc1a0f2..0000000
--- a/sites/research/src/content/reflections/teaching-philosophy.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "On Teaching Algorithms: Lessons from a Decade"
-description: "Reflections on what works (and what doesn't) in computer science education."
-pubDate: "Jan 10 2024"
-image: "https://images.unsplash.com/photo-1509062522246-3755977927d7?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# On Teaching Algorithms: Lessons from a Decade
-
-Ten years of teaching has taught me more than any textbook could.
-
-## Start with Why
-
-Students don't care about O(n log n) until they understand why their code is slow. Real problems first, theory second.
-
-## The Power of Visualization
-
-Abstract concepts become concrete when visualized. Every algorithm should have a picture.
-
-## Failure is a Feature
-
-Let students struggle. The struggle is where learning happens. But know when to throw a lifeline.
-
-## Assessment Philosophy
-
-Test understanding, not memorization. Open-book exams with novel problems beat closed-book regurgitation every time.
-
-## The Joy of "Aha!" Moments
-
-There's no feeling quite like seeing a student's eyes light up when a concept clicks. That's why we do this.
diff --git a/sites/research/src/content/research/conference-highlights-2024.md b/sites/research/src/content/research/conference-highlights-2024.md
deleted file mode 100644
index 73b6741..0000000
--- a/sites/research/src/content/research/conference-highlights-2024.md
+++ /dev/null
@@ -1,34 +0,0 @@
----
-title: "SODA 2024: Algorithmic Breakthroughs"
-description: "A roundup of fascinating algorithmic results from SODA 2024, focusing on graph algorithms and optimization techniques."
-pubDate: "Jan 15 2024"
-image: "https://images.unsplash.com/photo-1509228468518-180dd4864904?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# SODA 2024: Algorithmic Breakthroughs
-
-The Symposium on Discrete Algorithms (SODA) 2024 brought together researchers from around the world to present cutting-edge algorithmic research. This post highlights some of the most exciting developments in graph algorithms and optimization.
-
-## Graph Algorithms Revolution
-
-### Dynamic Graph Coloring
-
-One of the standout papers introduced a breakthrough in dynamic graph coloring with polylogarithmic update time. The authors developed a novel data structure that maintains a proper vertex coloring while supporting edge insertions and deletions efficiently.
-
-The key insight was to combine randomized recoloring strategies with a carefully designed hierarchical decomposition of the graph. This allows for local updates that rarely propagate through the entire structure.
-
-## Approximation Algorithms
-
-### The Traveling Salesman Problem Revisited
-
-A surprising result showed that for graphs with bounded doubling dimension, we can achieve a (1+ε)-approximation for TSP in nearly linear time. This improves upon decades of previous work and opens new avenues for practical implementations.
-
-## Complexity Theory Connections
-
-The conference also featured several papers bridging the gap between pure algorithmic research and complexity theory. A particularly elegant result showed that certain graph problems believed to require quadratic time are equivalent under fine-grained reductions.
-
-## Looking Forward
-
-These results demonstrate that fundamental algorithmic problems still have room for improvement. The techniques developed here will likely influence algorithm design for years to come.
diff --git a/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.003.jpeg b/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.003.jpeg
new file mode 100644
index 0000000..fb1567a
Binary files /dev/null and b/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.003.jpeg differ
diff --git a/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.006.jpeg b/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.006.jpeg
new file mode 100644
index 0000000..bdc6391
Binary files /dev/null and b/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.006.jpeg differ
diff --git a/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.007.jpeg b/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.007.jpeg
new file mode 100644
index 0000000..633a6ca
Binary files /dev/null and b/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.007.jpeg differ
diff --git a/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.008.jpeg b/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.008.jpeg
new file mode 100644
index 0000000..e1c9d77
Binary files /dev/null and b/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.008.jpeg differ
diff --git a/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.009.jpeg b/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.009.jpeg
new file mode 100644
index 0000000..06e4f54
Binary files /dev/null and b/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.009.jpeg differ
diff --git a/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.011.jpeg b/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.011.jpeg
new file mode 100644
index 0000000..c0b6abf
Binary files /dev/null and b/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.011.jpeg differ
diff --git a/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.027.jpeg b/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.027.jpeg
new file mode 100644
index 0000000..5a77e08
Binary files /dev/null and b/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.027.jpeg differ
diff --git a/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.028.jpeg b/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.028.jpeg
new file mode 100644
index 0000000..363230e
Binary files /dev/null and b/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.028.jpeg differ
diff --git a/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.030.jpeg b/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.030.jpeg
new file mode 100644
index 0000000..20dd939
Binary files /dev/null and b/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.030.jpeg differ
diff --git a/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.032.jpeg b/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.032.jpeg
new file mode 100644
index 0000000..ac70cd4
Binary files /dev/null and b/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.032.jpeg differ
diff --git a/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.035.jpeg b/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.035.jpeg
new file mode 100644
index 0000000..87f4214
Binary files /dev/null and b/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.035.jpeg differ
diff --git a/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.040.jpeg b/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.040.jpeg
new file mode 100644
index 0000000..871a9b8
Binary files /dev/null and b/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.040.jpeg differ
diff --git a/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.042.jpeg b/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.042.jpeg
new file mode 100644
index 0000000..219ba07
Binary files /dev/null and b/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.042.jpeg differ
diff --git a/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.044.jpeg b/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.044.jpeg
new file mode 100644
index 0000000..82b1eb1
Binary files /dev/null and b/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.044.jpeg differ
diff --git a/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.046.jpeg b/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.046.jpeg
new file mode 100644
index 0000000..9291ea0
Binary files /dev/null and b/sites/research/src/content/research/cp/sam-i-am/CP-Week09-Mod03.046.jpeg differ
diff --git a/sites/research/src/content/research/cp/sam-i-am/index.md b/sites/research/src/content/research/cp/sam-i-am/index.md
new file mode 100644
index 0000000..cf47edc
--- /dev/null
+++ b/sites/research/src/content/research/cp/sam-i-am/index.md
@@ -0,0 +1,176 @@
+---
+title: "Sam I Am"
+description: "This is mostly about solving Sam I Am (UVa 11419); en route, we will end up discovering Kőnig's theorem, which is a delightful fact about the special relationship shared by vert..."
+pubDate: "2021-10-01"
+authorName: "Neeldhara"
+sourceCategories: ["cp", "lecturenotes"]
+sourcePath: "cp/sam-i-am/index.qmd"
+---
+
+This is mostly about solving Sam I Am ([UVa 11419](https://onlinejudge.org/external/114/11419.pdf)); en route, we will end up discovering Kőnig's theorem, which is a delightful fact about the special relationship shared by vertex covers and maximum matchings in bipartite graphs.
+
+## The Problem
+
+Here's an abridged version of the problem statement.
+
+> Sam is facing a temple which can be described by a $m \times n$ grid and **he has the locations of all enemies in the temple** (each location can be thought of as the intersection of a row and a column in this grid).
+
+All of a sudden, he realizes that he can kill the enemies without entering the temple using the great cannon ball which spits out a gigantic ball bigger than him killing anything it runs into and keeps on rolling until it finally explodes.
+
+**But the cannonball can only shoot horizontally or vertically and all the enemies along the path of that cannon ball will be killed.**
+
+Sam wants to know the **minimum number of cannon balls** and the positions from which he can shoot the cannonballs **to eliminate all enemies** from outside that temple.
+>
+
+## Some initial observations with an example
+
+So to begin with, we have a grid with some cells identified as locations where Sam's enemies are positioned, and here's an example:
+
+![A first example of a configuration of Sam's enemies location](CP-Week09-Mod03.003.jpeg)
+
+> **Aside:** Conveniently for us, the enemies don't move around.
+
+We want to *hit* all of these locations, and what we have at our disposal is giant cannon balls which can destroy all enemies that are positioned on a single row, or a single column. For example, if we were obsessed about only firing along rows, we would need four cannon balls to tackle 'em all, like so:
+
+![A solution were we fire along rows alone](CP-Week09-Mod03.006.jpeg)
+
+If Sam was superstitious about shooting along columns only, then he would again need four of these cannon balls to take care of everything:
+
+![A solution were we fire along columns alone](CP-Week09-Mod03.007.jpeg)
+
+However, our friend Sam is smart, not superstitious! And if there is anything that he is obsessed about, it is ruthlessly optimal destruction! In other words, he wants to fix everything up, but while using the smallest number of cannon balls possible... and if that means mixing up ranks and files, so be it — notice that you can manage with just three once you combine the use of both axes:
+
+![A solution leveraging a combination of rows and columns](CP-Week09-Mod03.008.jpeg)
+
+And for this example in particular, notice that three cannon balls are *necessary*, because we have at least three enemies positioned at locations that share *neither a row nor a column*, implying that no row-fire or column-fire can handle more than one of these locations at once:
+
+![Demonstrating that three canonballs are in fact necessary](CP-Week09-Mod03.009.jpeg)
+
+So for this example, we know that:
+
+- three cannon balls are necessary &
+- three cannon balls are sufficient.
+
+In general, let's say that two enemy positions are *mutually independent* if they are on different columns *and* on different rows. Let $k$ be the size of a largest collection of mutually independent positions. Then it is clear that:
+
+- $k$ cannon balls are necessary to handle all enemy locations;
+
+because any $\ell$ fires that handle *all* enemy locations must in particular handle these $k$ mutually independent ones, and each individual fire can get to (at best) one of them — by definition of what it means for two positions to be mutually independent. So if we have a valid solution involving $\ell$ cannon balls, then $\ell \geq k$.
+
+What is a less obvious, but considerably fascinating, is the fact that:
+
+- there is always a strategy to hit *all* locations using just $k$ cannon balls. 🤯
+
+A striking situation, no pun intended — the obvious estimate of what is needed turns out to be enough as well! The easy lower bound has a matching upper bound ❤️
+
+## An auxiliary graph
+
+Alright, I think that's enough with the advertising.
+
+How does this work?
+
+Let's construct the following graph $G = (V,E)$ associated with the grid and the information about enemy positions:
+
+- Introduce a vertex for every row in the grid; say $r_i$ for $1 \leq i \leq m$. These are the *row vertices.*
+- Introduce a vertex for every column in the grid; say $c_j$ for $1 \leq j \leq n$. These are the *column vertices.*
+
+![The vertices of the auxiliary graph](CP-Week09-Mod03.011.jpeg)
+
+- Introduce the edge $(r_i,c_j)$, $1 \leq i \leq n; 1 \leq j \leq m$ if and only if the location at the intersection of the $i^{th}$ row and the $j^{th}$ column corresponds to an enemy position.
+
+![The edges of the auxiliary graph](CP-Week09-Mod03.027.jpeg)
+
+![A bipartite graph!](CP-Week09-Mod03.028.jpeg)
+
+Observe that:
+
+- Any matching in $G$ (a collection of mutually disjoint edges) corresponds to a collection of mutually independent enemy positions back in the grid.
+- What we are looking for is a smallest-sized subset $S$ of $V(G)$ such that every edge $e$ in $G$ has at least one of its endpoints in $S$. Such a subset is called a vertex cover.
+
+![A vertex cover](CP-Week09-Mod03.030.jpeg)
+
+So our claim in the language of grids now translates to:
+
+
+> 📝 The size of a maximum matching in $G$ is equal to the size of a minimum vertex cover in $G$.
+
+in the language of graphs. Keep in mind that as graphs go $G$, happens to be a bipartite graph; which is to say that its vertex set can be parittioned into two parts† such that every edge has exactly one endpoint in each part.
+
+> **Aside:** † In this example, these parts correspond to subsets of row vertices and column vertices.
+
+## Bring in the flows
+
+Is this much ado for nothing? We seem to have done some translation work, but there's no proof of this bold claim in sight just yet... 😬
+
+Fair. So here's a roadmap for what we plan to do next:
+
+- Use the graph $G$ as the basis of a flow network.
+- Recall the maxflow-mincut duality.
+- ~~Profit.~~ Show the duality that we are interested in by hooking it up the known one.
+
+So first things first: we are going to setup a flow network around the graph $G$, and here's a partial picture of what it looks like:
+
+![The flow graph](CP-Week09-Mod03.032.jpeg)
+
+Here's the official description of how we build this up:
+
+- Start with the graph $G$, and orient every edge between a row vertex and a column vertex so that every such edge originates *from* the row vertex and latches on *to* the column vertex.
+- We assign infinite capacities to all the edges in $G$. Go unlimited on the originals! We will even dub these edges *original edges* going forward.
+- Add a source vertex $s$ and add unit-capacity edges $(s,r)$ for every row vertex $r$. We will call these edges the *row selectors.*
+- Add a target vertex $t$ and add unit-capacity edges $(c,t)$ for every column vertex $c$. We will refer to these edges as *column selectors.*
+
+That's it, that's the flow network $(\tilde{G},\kappa)$ based on $G$, where I'm using $\kappa$ to denote the capacity function. Now let's stare at any valid integral flow in this network — what does it pull out from the middle? 🤔
+
+![A matching hiding in plain sight](CP-Week09-Mod03.035.jpeg)
+
+Let's make the following quick observations in the context of a valid integral flow $f$ in $(\tilde{G},\kappa)$:
+
+- The flow on any edge $e$ from $G$ (i.e, an original edge) is either zero or one. Indeed, if $f(e) > 1$, then we violate conservation constraints at both endpoints of $e$.
+- For any row or column vertex, at most one original edge incident to it is used by the flow $f$. In other words, $f(e) = 0$ for all but at most one original edge incident to any row or column vertex. Again, if not, combined with the fact that $f$ is integral and that the row and column selectors have unit capacity, we will violate conservation constraints on the vertex under consideration.
+
+Based on these observations, we have that the set of original edges for which $f(e) = 1$ forms a matching in back in $G$, and in particular, if $f$ was maximum flow, then this set would correspond to a maximum-sized matching. Now, let's look at the corresponding mincut by building the residual graph:
+
+![Edges in the residual graph that have a residual capacity of zero are not shown. Also, the original edges that were used by $f$ have infinite residual capacity but their corresponding back-edges have unit capacity, but this distinction is not emphasised in the picture because it's not particularly relevant to our discussion.](CP-Week09-Mod03.040.jpeg)
+
+Edges in the residual graph that have a residual capacity of zero are not shown. Also, the original edges that were used by $f$ have infinite residual capacity but their corresponding back-edges have unit capacity, but this distinction is not emphasised in the picture because it's not particularly relevant to our discussion.
+
+and considering what vertices are reachable from $s$:
+
+![The vertices reachable from $s$ are marked green, while all remaining vertices are marked red.](CP-Week09-Mod03.042.jpeg)
+
+The vertices reachable from $s$ are marked green, while all remaining vertices are marked red.
+
+In the residual graph, I would like to draw your attention to:
+
+- row vertices that are unreachable from $s$,
+- column vertices from where it is impossible to reach $t$.
+
+We will refer to these vertices as the *misfits —* they are highlighted for you in the picture below:
+
+![The misfits](CP-Week09-Mod03.044.jpeg)
+
+Now roll up your sleeves for some magic. Let's pull up the cut — which we know is in fact a mincut — obtained by considering the set of vertices reachable from $s$ the residual graph corresponding to the maxflow $f$. In pictures, note how we have attracted some column vertices to the $s$-side, and pushed away some row vertices to the $t$-side:
+
+![Some reorganization](CP-Week09-Mod03.046.jpeg)
+
+Note that this is a minimum cut, that is to say, the total capacity of the edges crossing the cut is as small as possible — which means that, in particular, the total capacity is at least (or should that be at most?) finite, and that implies, even more particularly, that *none*[^1] of the original edges cross this cut.
+
+[^1]: Remember how their capacities were infinite? So they just cannot afford to cross a minimum-capacity cut.
+
+So every original edge is confined to the $s$-camp or the $t$-camp; but note that every original edge is an edge between a row vertex and a column vertex; so if you put two and two together, you see that, in fact, *every edge must be incident to a misfit vertex.* This means that the misfits are what we were looking for all along — they form a vertex cover of $G$!
+
+So at least we have *some* solution. Is this the best we can hope for?
+
+Why yes!
+
+Note that every misfit vertex contributes *exactly one unit-capacity edge* to the minimum cut: the misfits on the $s$-side are incident to column selectors, and these edges connect with $t$ on the other side; while misfits on the $t$-side are incident to row selectors, and these edges connect with $s$, which is again on the opposite end. So every misfit vertex contributes exactly one edge to the minimum cut — and there are no other edges that cross the cut, so we have the following sequence of equalities:
+
+- size of the proposed solution = #misfits
+- #misfits = capacity of the minimum cut
+- capacity of the minimum cut = value of the maximum flow
+- value of the maximum flow = size of a maximum matching back in $G$
+- size of a maximum matching back in $G$ = lower bound on our solution
+
+Therefore, we have proposed a solution whose cost matches a lower bound on it, making it optimal! With a slight adjustment of language (dropping misfits in favor of vertex cover), the sequence of inequalities above also shows that the size of a minimum vertex cover in a bipartite graph equals the size of a maximum matching in the graph.
+
+This was the relationship I'd promised to cover when we started, and it goes by Kőnig's theorem in case you'd like to find out more — the argument we came up with here isn't perhaps the traditional proof, and this is a fact that can be established in several different ways, all fun in their own way ❤️
diff --git a/sites/research/src/content/research/crypto-intro/index.md b/sites/research/src/content/research/crypto-intro/index.md
new file mode 100644
index 0000000..a7fbc26
--- /dev/null
+++ b/sites/research/src/content/research/crypto-intro/index.md
@@ -0,0 +1,142 @@
+---
+title: "Intro to Crypto"
+description: "Caution Background This post is based on a series of lectures that Venkata Koppula gave at IIT Gandhiangar during the inter-IIT sports meet. Lecture 1: How to define security? N..."
+pubDate: "2023-12-21"
+authorName: "Neeldhara"
+sourceCategories: ["talk", "exposition"]
+sourcePath: "crypto-intro/index.qmd"
+---
+
+> **Caution**
+> 
+> # Background
+> This post is based on a series of lectures that [Venkata Koppula](https://web.iitd.ac.in/~kvenkata/) gave at IIT Gandhiangar during the inter-IIT sports meet.
+
+
+## Lecture 1: How to define security?
+
+
+> **Note**
+> 
+> # A first threat scenario, informally:
+> 
+> 
+> - A king and an admiral share some secret information beforehand.
+> - Later, the king wants to send exactly one message.
+> - The admiral should learn the message.
+> - No one else should learn anything.
+> 
+
+
+### Encrpytion and Decryption
+
+The setup:
+
+Let $\mathcal{A}$ be an abitrary but fixed set of symbols, which we call the alphabet.
+
+- The _key space_ $\mathcal{K}$ is a set of strings over $\mathcal{A}$.
+- The _message space_ $\mathcal{M}$ is also a set of strings over $\mathcal{A}$.
+- The _ciphertext space_ $\mathcal{C}$ is also a set of strings over $\mathcal{A}$.
+
+We also have two functions:
+
+1. The **encryption** function:
+
+$$\mathfrak{E}: \mathcal{K} \times \mathcal{M} \longrightarrow \mathcal{C},$$
+
+   which takes as input a key $k \in \mathcal{K}$ and a message $m \in \mathcal{M}$, and outputs a ciphertext $c \in \mathcal{C}$.
+
+2. The **decryption** function:
+
+$$\mathfrak{D}: \mathcal{K} \times \mathcal{C} \longrightarrow \mathcal{M} \cup \{\bot\},$$
+
+   which takes as input a key $k \in \mathcal{K}$ and a ciphertext $c \in \mathcal{C}$, and outputs a message $m \in \mathcal{M}$ or the symbol $\bot$ (which is pronounced _bottom_, and captures a failure signal, e.g, on a corrupt input).
+
+
+The encrpytion scheme is said to be _valid_ if for all $(k,m) \in \mathcal{K} \times \mathcal{M}$, it holds that:
+
+$$\mathfrak{D}(k, \mathfrak{E}(k, m)) = m$$
+
+### A Secruity Definition
+
+Once we have a proposal for a valid encryption/decryption scheme, we would like to know if it is a decent one: and in our context, we like schemes that can survive adverserial attacks: imagine someone snooping over the communication channel, and trying to learn the message from the ciphertext --- we would like to make claims to the effect of "that won't be possible".
+
+To formalize this, we have the notion of a security game, which is a game played between two players: a challenger and an adversary. The challenger is the one who sets up the game, and the adversary is the one who tries to break the scheme. Here's what the game looks like:
+
+1. The challenger picks a key $k \in \mathcal{K}$ uniformly at random and a picks a bit $b \in \{0,1\}$ uniformly at random
+2. The adversary sends the challenger two messages $m_0$ and $m_1$.
+3. The challenger sends the ciphertext $c = \mathfrak{E}(k, m_b)$ to the adversary.
+4. The adversary outputs a bit $b'$.
+5. The adversary wins if $b = b'$.
+
+Note that an adversary that outputs a bit in step 4 by tossing a coin (`1` if `H` and `0` if `T`) wins this game with probability $1/2$.
+
+A self-respecting adversary will want to fare better, while a scheme worth its salt will not want to be vulnerable with respect to _any_ adverseray, so we say that:
+
+- an adversary wins this game if they can win it with probability greater than half, and,
+- a scheme is secure if no adversary can win this game with probability greater than half.
+
+### Example: An Insecure Scheme
+
+Consider a lazy encryption scheme that does not encrypt a message at all:
+
+- $\mathfrak{E}(k,m) = m$ and
+- $\mathfrak{D}(k,c) = c$.
+
+It is easy to see that there is an adversary who can win the security game defined above with probability 1, so this is not a terribly smart scheme. The same is true for schemes that rotate the message by a fixed amount (why?).
+
+
+### Example: An Secure Scheme
+
+Assume the message space, key space, and ciphertext space are all $n$-bit strings for some arbitrary but fixed choice of $n$. Consider the following encryption scheme:
+
+- $\mathfrak{E}(k,m) = k \oplus m$ and
+- $\mathfrak{D}(k,c) = k \oplus c$.
+
+It turns out that this scheme is secure, intuitively because for any ciphertext $c$, there are two keys $k_1$ and $k_2$ which are such that:
+
+- $\mathfrak{D}(k_1,c) = m_0$, and
+- $\mathfrak{D}(k_2,c) = m_1$,
+
+for any two messages $m_0$ and $m_1$, so there is no way for the adversary to reverse engineer the bit $b$.
+
+(Exercise: prove this formally.)
+
+### Example: Another Insecure Scheme
+
+
+Assume the message space and ciphertext space are $2n$-bit strings for some arbitrary but fixed choice of $n$, and the key space is the set of all $n$-bit strings. Consider the following encryption scheme:
+
+- $\mathfrak{E}(k,m) = (k | k) \oplus m$ and
+- $\mathfrak{D}(k,c) = (k | k) \oplus c$,
+
+where $(a | b)$ denotes the concatenation of two strings.
+
+It turns out that this scheme is _not_ secure (why?).
+
+
+### A Stronger Secruity Definition
+
+Consider the following extended security game:
+
+1. The challenger picks a key $k \in \mathcal{K}$ uniformly at random and a picks a bit $b \in \{0,1\}$ uniformly at random.
+2. The adversary sends the challenger two messages $m_{00}$ and $m_{01}$.
+3. The challenger sends the ciphertext $c_0 = \mathfrak{E}(k, m_{0b})$ to the adversary.
+4. The adversary sends the challenger two messages $m_{10}$ and $m_{11}$.
+5. The challenger sends the ciphertext $c_1 = \mathfrak{E}(k, m_{1b})$ to the adversary.
+6. The adversary outputs a bit $b'$.
+7. The adversary wins if $b = b'$.
+
+As before, we say that:
+
+- an adversary wins this game if they can win it with probability greater than half, and,
+- a scheme is secure if no adversary can win this game with probability greater than half.
+
+However, in the extended game, we have empowered the adversary to a point where _no_ deterministic scheme can be secure in this stronger sense! Here's why:
+
+- Suppose the adversary picks: $m_{00} = 0^n$, $m_{01} = 1^n$, $m_{10} = 0^n$, $m_{11} = 01^{n-1}$.
+- Then the adversary returns $0$ if $c_0$ and $c_1$ are identical, and $1$ otherwise.
+
+Note that this particular adversary wins with probability 1, no matter what $\mathfrak{E}$ and $\mathfrak{D}$ are.
+
+What can we say about _randomized_ schemes? Can they be secure in the extended setting?
diff --git a/sites/research/src/content/research/distributed-algorithms.md b/sites/research/src/content/research/distributed-algorithms.md
deleted file mode 100644
index e577220..0000000
--- a/sites/research/src/content/research/distributed-algorithms.md
+++ /dev/null
@@ -1,34 +0,0 @@
----
-title: "Distributed Computing: Recent Advances"
-description: "Survey of recent developments in distributed algorithms from major conferences."
-pubDate: "Feb 20 2024"
-image: "https://images.unsplash.com/photo-1558618666-fcd25c85cd64?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Distributed Computing: Recent Advances
-
-The field of distributed computing has seen remarkable progress in recent years. This post surveys key results from PODC, DISC, and other major venues.
-
-## Consensus Protocols
-
-### Byzantine Agreement in Asynchronous Networks
-
-A breakthrough result achieves optimal resilience with expected constant rounds. The protocol uses cryptographic techniques combined with novel committee selection.
-
-## Distributed Graph Algorithms
-
-### Minimum Spanning Tree in the CONGEST Model
-
-New algorithms achieve near-optimal round complexity for MST construction. The approach uses sophisticated graph decomposition techniques.
-
-## Local Algorithms
-
-### The Power of Local Computation
-
-Recent work characterizes which problems admit constant-time local algorithms. The classification provides a complete picture for bounded-degree graphs.
-
-## Future Directions
-
-The intersection of distributed computing with machine learning presents exciting opportunities for both fields.
diff --git a/sites/research/src/content/research/git-automation.md b/sites/research/src/content/research/git-automation.md
deleted file mode 100644
index 2ae09cd..0000000
--- a/sites/research/src/content/research/git-automation.md
+++ /dev/null
@@ -1,54 +0,0 @@
----
-title: "Git Workflows That Save My Sanity"
-description: "Automation scripts and Git hooks that eliminate repetitive tasks and prevent common mistakes."
-pubDate: "Jan 22 2024"
-image: "https://images.unsplash.com/photo-1556075798-4825dfaaf498?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Git Workflows That Save My Sanity
-
-After years of Git mishaps, I've built workflows that prevent disasters and save hours weekly.
-
-## The Pre-commit Hook That Saves Embarrassment
-
-```bash
-#!/bin/bash
-# Check for debugging statements
-if grep -r "console.log\|debugger\|TODO" --include="*.js" .; then
-  echo "⚠️  Debugging statements found!"
-  exit 1
-fi
-```
-
-## Automatic Branch Naming
-
-```bash
-alias feature='git checkout -b feature/$(date +%Y%m%d)-$1'
-```
-
-Now `feature "user-auth"` creates `feature/20240122-user-auth`.
-
-## The Commit Message Template
-
-```
-[TYPE] Brief description
-
-Why:
-- Context for this change
-
-What:
-- Specific changes made
-
-Testing:
-- How to verify it works
-```
-
-## The Weekly Cleanup Script
-
-Deletes merged branches, prunes remotes, and garbage collects. Keeps the repo clean and fast.
-
-## ROI
-
-These automations save ~5 hours per week and countless prevented mistakes. The time invested in setting them up paid back in days.
diff --git a/sites/research/src/content/research/homework-help/index.md b/sites/research/src/content/research/homework-help/index.md
new file mode 100644
index 0000000..7e8b2a9
--- /dev/null
+++ b/sites/research/src/content/research/homework-help/index.md
@@ -0,0 +1,93 @@
+---
+title: "How Expensive Can Homework Help Be?"
+description: "Note This post is based on an expository explanation of iterative compression that I attempted at the Institute Seminar Week in 2010, at IMSc. Tapesh has been struggling lately..."
+pubDate: "2010-05-01"
+authorName: "Neeldhara"
+sourceCategories: ["exposition", "parameterized-algorithms"]
+sourcePath: "homework-help/index.qmd"
+---
+
+> **Note**
+> 
+> This post is based on an expository explanation of [iterative compression](https://en.wikipedia.org/wiki/Iterative_compression) that I attempted at the Institute Seminar Week in 2010, at IMSc.
+
+
+Tapesh has been struggling lately with the dire task of undergraduate homework. He has been asked to find a [vertex cover](http://en.wikipedia.org/wiki/Vertex_cover) on 23 vertices - not one more - in a graph that has a thousand vertices. Being the straightforward boy that he is, Tapesh considers writing a program that will try its luck on every possible subset of 23 vertices.
+
+He then heads over to Wolfram Alpha to check how long it will be before he’s done examining all the ${1000 \choose 23}$ possibilities, assuming (rather liberally) that he has at his disposal a computer that can perform $10^{24}$ operations per second.
+
+It turns out that he, and more critically, his professor, would be in for a long, long wait. The algorithm would need time proportional to the age of the universe many times over, and this is decidedly depressing, particularly when one’s expected lifespan appears to be determined by the deadline for turning in homework.
+
+Tapesh now appeals to his very clever cousin, Prodosh, for help.
+
+Prodosh borrows the monstrous graph, and in short order, points out a vertex cover on 24 vertices, using powers evidently beyond what processors with $10^{24}$ FLOPS can do. Tapesh is thrilled, however…
+
+“I need to get one with 23, the assignment says not one more —”
+
+“Time for a smoke,” Prodosh yawns, and then delves into a distracted, pensive mood, with no signs of immediate return.
+
+Tapesh is torn, but he decides to (gulp) show whatever he has so far - after all, it is progress!
+
+Predictably, Professor Maganlal displays no signs of being impressed, but he grudgingly admits that Tapesh’s solution (which we will call $T$) is not very far from the correct answer, and points out those vertices in $T$ that happen to partake in the solution that was sought.
+
+Tapesh is back to the drawing board, but with the distinct feeling that he is now armed with enough information to crack the code himself.
+
+His solution $T$ is now partitioned into the _good part_ ($T_G$), that is, all the vertices of $T$ that belong to $X$, and the _bad part_ ($T_B$), which are all the vertices that do not belong to X.
+
+“Aha.”
+
+Necessarily, all the neighbors of the bad part must belong to $X$!
+
+He checks, and sure enough, the number of vertices in $T_G$ and $N(T_B)$ is an exact, resounding 23. Also, very fortunately, there are no edges in $T_B$, so he has no trouble swapping $T_B$ for $N(T_B)$ to get to the newer and smaller vertex cover.
+
+Mission accomplished!
+
+Now more confident, Tapesh wonders if he could have arrived at $X$ all on his own. Indeed, what would he have done without Pradosh’s help? And without Professor Maganlal giving him that partition?
+
+Come to think of it, the second question has an easy answer. Tapesh would just try all possible partitions of the solution that Pradosh had given him. He would only have to disregard the partitions that didn’t work… and sooner or later, he would hit the one that his Professor so graciously suggested. This would mean examining $2^{24}$ subsets, a matter of a split second for a personal computer.
+
+But - can he replicate Pradosh’s magic on his own?
+
+Tapesh is up into the middle of the night waiting for the brainwave that will make him completely self-dependent, at least in the broad context of finding small vertex covers in large graphs.
+
+He is still impressed that he has just found a general scheme for taking a vertex cover of size 24 and bringing it down to 23. Wanting to make the most of the only trick he knew, he wondered if he could use it more than once.
+
+So he looked at the 1,000-vertex monstrosity and contemplated the possibility of working with a manageable chunk first. What if he selected an easy subgraph $H$ for isolated consideration? Surely, if $G$ has a vertex cover of 23 vertices, $H$ has one too. So all he would need is to find a vertex cover on 24 vertices, and he already knew how to squish it to one of size 23.
+
+What was the easiest chunk that he could work with? One on which finding a vertex cover of size 24 wasn’t hard?
+
+But of course, a subgraph on 24 vertices would be really easy to deal with!
+
+The entire graph $H$ would serve as its own vertex cover, would be of size 24 — it couldn’t get easier than that.
+
+So Tapesh starts by selecting the first 24 vertices that he can find, and applies his squishing strategy to find a vertex cover on 23 vertices.
+
+What now?
+
+He gives the remaining 976 vertices a hesitant look.
+
+Maybe it was time to grow $H$ to include some more vertices? If Tapesh could get $H$ to eventually morph into being all of $G$, he would be done!
+
+But if he added a whole bunch of new vertices, he would need to do something about finding a vertex cover of size 24 in the bigger $H$ to make progress… but that sounded like work :(
+
+Maybe, maybe just let in _one more vertex_ into the precious subgraph $H$? Indeed, there is enough room in the vertex cover of size 23 for one more vertex. So $H$ would grow by a single vertex, and so would the vertex cover - and then Tapesh could squish it again!
+
+And there is no stopping Tapesh from repeating this 975 times more, and each time, the reincarnated $H$ would be one larger than before, and every time he would beat down the vertex cover to one of size 23, till he got to the end.
+
+But, Tapesh wonders sleepily, wouldn’t this take awfully long?
+
+The squishing was quick, and now it has to be done 977 times altogether… and even at the lesiurely pace of doing one iteration in one second, you would need less than half an hour before you finished.
+
+Not too shabby — certainly no waiting for universes to come and go!
+
+In general, the problem of finding a vertex cover of size $k$ in a graph on $n$ vertices vertices can be done in time:
+
+$$O((n-k) \cdot 2^{k+1})$$
+
+following the recipe in this story.
+
+If this algorithm aborts, unable to find a vertex cover of size $k$, it is because a subgraph did not have a vertex cover of size $k$. Of course, this also means that the entire graph does not have a vertex cover of size $k$ either, so the process makes sense.
+
+It is important to note that not every problem is designed to fit this bill, for instance, if the next homework assignment demands a vertex cover that is also connected, the iteration procedure, as it stands, might not be accurate when it reports a negative answer.
+
+The next assignment, therefore, potentially leads to a more demanding adventure.
diff --git a/sites/research/src/content/research/kidney-exchanges/image.jpg b/sites/research/src/content/research/kidney-exchanges/image.jpg
new file mode 100644
index 0000000..3ec04c8
Binary files /dev/null and b/sites/research/src/content/research/kidney-exchanges/image.jpg differ
diff --git a/sites/research/src/content/research/kidney-exchanges/index.md b/sites/research/src/content/research/kidney-exchanges/index.md
new file mode 100644
index 0000000..48cc851
--- /dev/null
+++ b/sites/research/src/content/research/kidney-exchanges/index.md
@@ -0,0 +1,145 @@
+---
+title: "Kidney Exchanges"
+description: "This post is based on an excellent (chalk and board!) talk that Palash Dey gave at IIT Gandhinagar today. This is his joint work with Arnab Maiti, to appear as an extended abstr..."
+pubDate: "2022-02-25"
+authorName: "Neeldhara"
+sourceCategories: ["talk", "exposition"]
+sourcePath: "kidney-exchanges/index.qmd"
+---
+
+This post is based on an excellent (chalk and board!) talk that [Palash Dey](https://cse.iitkgp.ac.in/~palash/) gave at IIT Gandhinagar today. This is his joint work with [Arnab Maiti](https://sites.google.com/view/arnab-maiti/home), to appear as an [extended abstract](https://aamas2022-conference.auckland.ac.nz/accepted/extended-abstracts/) at [AAMAS 2022](https://aamas2022-conference.auckland.ac.nz/) ([preprint here](https://arxiv.org/pdf/2112.10250.pdf)).
+
+
+## Background
+
+[Kidney paired donation](https://en.wikipedia.org/wiki/Kidney_paired_donation) or *paired exchange* allows donors to donate their kidneys to compatible patients with the understanding that their patients receive medically compatible kidneys in turn. The central problem in this setting is the *clearing problem —* which involves matching patients to donors in such a way that a maximum number of patients receive compatible kidneys. We introduce a directed graph as a convenient abstraction for this question, where:
+
+- each node $v_i = (P_i,D_i)$ represents a patient-donor pair, and
+- we introduce a *directed* edge $v_i → v_j$ if the kidney of the donor $D_i$ is compatible with the patient $P_j$.
+
+Observe that a cycle in this directed graph naturally represents a sequence of feasible exchanges within the cycle. For example, imagine that we have a three-cycle with the edges:
+
+$(P_2,D_2) → (P_5,D_5) → (P_7,D_7) → (P_2,D_2)$
+
+Then we have the following compatible donations:
+
+- $P_5$ is assigned the kidney of donor $D_2$
+- $P_7$ is assigned the kidney of donor $D_5$
+- $P_2$ is assigned the kidney of donor $D_7$
+
+This accounts for all the patients and donors involved in this cycle and motivates the following question:
+
+> Given a directed graph, what is the largest number of vertices that can be covered by a disjoint union of cycles?
+
+While a positive answer to this question will “resolve” all the needs in the system, consider that exchanges along a cycle of length $\ell$ involve $\ell$ simultaneous operations to mitigate the risks involved with donors potentially backing out of the exchange agreements.
+
+This motivates the following refinement of the previously posed question:
+
+> Given a directed graph, what is the largest number of vertices that can be covered by a disjoint union of cycles, where each cycle is of length $\ell$ or less?
+
+If the exchanges are restricted to swaps, that is, $\ell = 2$, the problem reduces to finding a maximum matching. However, the problem is NP-complete already when $\ell = 3$ (see Theorem 1, [Abraham, Blum, and Sandholm](https://www.cs.cmu.edu/~sandholm/kidneyExchange.EC07.withGrantInfo.pdf); EC 2007).
+
+We now generalize the model a little further to account for the presence of *[altruistic donors](https://en.wikipedia.org/wiki/Organ_transplantation#Good_Samaritan),* who are donors without a matching patient and are willing to donate to any compatible patient. To account for the presence of such donors, we modify our graph representation as follows:
+
+- Each node either:
+    - represents a patient-donor pair $v_i = (P_i,D_i)$ or
+    - represents an altruistic donor $u_k = D_k^\star$
+- The edges are as follows:
+    - We have a *directed* edge $v_i → v_j$ if the kidney of the donor $D_i$ is compatible with the patient $P_j$.
+    - We have a *directed* edge $u_k → v_j$ if the kidney of the donor $D_k^\star$ is compatible with the patient $P_j$.
+
+In this setting, note that we can also facilitate exchanges along *paths* as well, with the paths starting at the altruistic donors. For instance, if we have the path:
+
+$(D_7^\star) → (P_2,D_2) → (P_5,D_5) → (P_7,D_7) → (P_3,D_3)$
+
+Then we have the following compatible donations:
+
+- $P_2$ is assigned the kidney of donor $D_7^\star$
+- $P_5$ is assigned the kidney of donor $D_2$
+- $P_7$ is assigned the kidney of donor $D_5$
+- $P_3$ is assigned the kidney of donor $D_7$
+
+Note that in this situation, the donor $D_3$ is relieved from any obligation to donate to a patient. We now update our problem statement to reflect the presence of altrustic donors and the possibility of facilitating exchanges along paths:
+
+> 🤝 Optimal Kidney Exchange Along Short Paths and Cycles
+>
+> **Input.** A directed graph $G = (V,E)$, where $\mathcal{A} \subseteq V$ are source vertices; and positive integers $\ell_p$, $\ell_c$ and $t$.
+>
+> **Output.** Yes if and only if there is a collection of cycles of length at most $\ell_c$ each and a collection of paths of length at most $\ell_p$ each such that the cycles and paths altogether covers $t$ nodes outside of $\mathcal{A}$.
+
+
+The main claim in the context of this problem is the following:
+
+There exists a $\mathcal{O}(2^{\mathcal{O}(t)} \cdot \text{poly}(n))$ that decides Optimal Kidney Exchange Along Short Paths and Cycles.
+
+## An Algorithm for OKE
+
+Here’s a high-level description of the algorithm (perhaps best approached with some prior familiarity with [color coding](https://www.youtube.com/watch?v=_4opS8Hpvc0&list=PLEAYkSg4uSQ2jI2x3Bwm711Tmjj-E25Et&index=19)). To begin with, notice that we may assume without loss of generality that $\ell_p \leq t$ and $\ell_c \leq t$ — intuitively, this is because if the permitted cycle and path lengths are longer than the number of patients we hope to cover, then we can simply look for cycles or paths of length $t$ directly to begin with — if we find one, then we are done, and if none exist, then we “might as well” set $\ell_p$ and/or $\ell_c$ to $t-1$.
+
+Now, if there is a solution that accounts for at least $t$ patients, there is also one that involves at most $2t$ patients and in particular, also at most $t$ paths. Such a solution engages at most $t$ nodes from $\mathcal{A}$. Therefore, if there is a solution, then there is one that spans $s \leq 3t$ vertices.
+
+As is standard for color coding, we guess the correct value of $s$ and randomly partition the vertex set $V$ into $s$ parts. The hope is that each part contains exactly one vertex from the solution (this is a so-called “colorful solution”). The probability that a random partition is a lucky one is $(3t)!/(3t)^{(3t)}$, which turns out to be at least $e^{-3t}$. This implies that $e^{3t}$ repetitions ensure a constant success probability.
+
+Given that the partition is indeed a lucky one, we can recover the solution using the following dynamic programming semantics. For $C \subseteq [3t]$ and $i \in [3t]$, let $D[C,i]$ be **TRUE** if and only if there is a colorful solution spanning at least $i$ nodes outside $\mathcal{A}$ in $G[V_C]$, where $V_C$ denotes the subset of vertices colored with colors from $C$.
+
+The recurrence is based on isolating one path or cycle by guessing the set of colors involved in said component and using table lookups to figure out if this can be extended to a full solution.
+
+In particular, we have:
+
+$D[C,i] = P[C,i] \lor Q[C,i]$,
+
+where
+
+$P[C,i] = \lor_{(B,j): B \subseteq C \text{ and } 1 \leq j \leq \ell_c} [D[C \setminus B, i - j] \land f(B,j)]$
+
+and
+
+$Q[C,i] = \lor_{(B,j): B \subseteq C \text{ and } 1 \leq j \leq \ell_p} [D[C \setminus B, i - j] \land g(B,j)]$.
+
+Here, we have that:
+
+- $f(B,j)$ is **TRUE** if and only if the vertices of $B$ can be covered with a cycle of length $j$.
+- $g(B,j)$ is **TRUE** if and only if the vertices of $B$ can be covered with a path of length $j$.
+
+The truth values of $f(B,j)$ and $g(B,j)$ can be determined directly using standard approaches to finding colorful paths and cycles in time that is single-exponential in $j$.
+
+To claim the overall running time, note that:
+
+- The total number of entries in the table is $2^{O(t)} \cdot t$ and each entry can be computed in time $\mathcal{O}^{}\left(2^{\mathcal{O}(\ell)}\right).$
+- Therefore, the algorithm outputs the correct decision in $\mathcal{O}^{}\left(2^{\mathcal{O}(t)}\right)$ time with probability at least $e^{-3t}$,
+- By repeating $\mathcal{O}\left(e^{3 t}\right)$ times, we find the correct decision with constant success probability.
+- The overall running time is $\mathcal{O}^{*}\left(2^{\mathcal{O}(t)}\right)$.
+
+## Other Results
+
+As Palash mentioned in his talk, the preprint has more, and here are some highlights of the other results that were established:
+
+1. Optimal Kidney Exchange Along Short Paths and Cycles is [FPT](https://en.wikipedia.org/wiki/Parameterized_complexity#FPT) also when parameterized by the treewidth of the underlying graph $+$ maximum length of path $\left(\ell_{p}\right)+$ maximum length of cycle allowed $\left(\ell_{c}\right)$ and the number of vertex types[^1] when $\ell_{p} \leq \ell_{c}$.
+
+2. A [Monadic second-order formula](https://en.wikipedia.org/wiki/Monadic_second-order_logic) for the problem is also presented, where the length of the formula is upper bounded by a function of $\ell=\max \left\{\ell{c}, \ell_{p}\right\}$.
+
+3. The problem admits a [polynomial kernel](https://en.wikipedia.org/wiki/Kernelization) with respect to the number of patients receiving kidneys $+$ maximum degree when $\max \left\{\ell_{p}, \ell_{c}\right\}$ is a constant.
+
+4. On the other hand, the problem does *not* admit any polynomial kernel parameterized by the number of patients receiving kidneys $+$ maximum degree $+\max \left\{\ell_{p}, \ell_{c}\right\}$ (under standard assumptions).
+
+5. A $\left(16/9+\epsilon\right)$-approximation algorithm is presented for the case when only cycles of length at most 3 are allowed and no paths are allowed.
+
+[^1]: [Dickerson, Manlove, Plaut, Sandholm, and Trimble.](https://arxiv.org/pdf/1606.01623.pdf) (EC 2016) introduced the notion of “vertex type" and showed its usefulness as a graph parameter in real-world kidney exchange instances. Two vertices is said to have the same vertex type if their neighbourhoods are the same.
+
+## Pointers
+
+
+Some discussion that came up during the talk:
+
+1. The so-called dual parameter $(n-t)$, which in this case corresponds to the number of patients who were “left out”, is perhaps a natural parameter to study as well.
+
+2. The notion of a patient without a matching donor seems complementary notion of altrusitic donors. Such patients would be the last vertices on paths kickstarted by altruistic donors. However, this notion likely does not manifest in practice.
+
+If you’d like to dig deeper, be sure to [check out the preprint](https://arxiv.org/pdf/2112.10250.pdf)! A few additional pointers:
+
+1. This work closely builds on the works of [Xiao and Wang](https://www.ijcai.org/proceedings/2018/77) (IJCAI, 2018), who proposed an exact algorithm with running time $\mathcal{O}(2^nn^3)$ where $n$ is the number of vertices in the underlying graph. They also show an FPT algorithm parameterized by the number of vertex types if we do not have any restriction on the length of cycles and chains.
+
+2. [Lin, Wang, Feng, and Fu](https://www.mdpi.com/1999-4893/12/2/50) (Algorithms, 2019) studied the version of the kidney exchange
+problem which allows only cycles and developed a randomized parameterized algorithm with respect to the parameter being (number of patients receiving a kidney, maximum allowed length of any cycle).
+
+3. Alvin E. Roth was awarded the Nobel Prize in Economic Sciences 2012 (along with Lloyd S. Shapley) in part for his pioneering contributions to the theory and practice of kidney exchange — his [biographical account](https://www.nobelprize.org/prizes/economic-sciences/2012/roth/biographical/) indicates that he had started anticipating the problem even before it emerged as a legal practice. His [talk at Simons Institute](https://www.youtube.com/watch?v=exB1O3pTf7E) surveys “fifteen years of history” in the kidney exchange problem, with an emphasis on the game-theoretic aspects. (h/t: [Rohit’s blog](https://csatravelblog.wordpress.com/2016/04/05/rohit-vaish-cmu-visit/) on this topic.)
diff --git a/sites/research/src/content/research/obsidian-academic.md b/sites/research/src/content/research/obsidian-academic.md
deleted file mode 100644
index 7e1c181..0000000
--- a/sites/research/src/content/research/obsidian-academic.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "Academic Writing with Obsidian and Pandoc"
-description: "A complete workflow for academic papers - from notes to publication-ready PDFs."
-pubDate: "Feb 12 2024"
-image: "https://images.unsplash.com/photo-1456324504439-367cee3b3c32?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Academic Writing with Obsidian and Pandoc
-
-Transform your scattered research notes into beautiful academic papers with this workflow.
-
-## The Setup
-
-- **Obsidian**: For note-taking and knowledge management
-- **Pandoc**: For document conversion
-- **LaTeX**: For typesetting
-- **Zotero**: For reference management
-
-## The Magic Command
-
-```bash
-pandoc paper.md \
-  --filter pandoc-citeproc \
-  --bibliography=refs.bib \
-  --template=academic.tex \
-  -o paper.pdf
-```
-
-## Templates for Everything
-
-From conference submissions to journal articles, templates ensure consistency and save time.
-
-## Version Control Integration
-
-Git + Obsidian = perfect history of your thinking process.
-
-## The Result
-
-From messy notes to camera-ready PDF in minutes, not hours.
diff --git a/sites/research/src/content/research/paper-review-approximation.md b/sites/research/src/content/research/paper-review-approximation.md
deleted file mode 100644
index 10d7c78..0000000
--- a/sites/research/src/content/research/paper-review-approximation.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "Understanding the Latest Approximation Algorithm for Set Cover"
-description: "A detailed walkthrough of a breakthrough approximation algorithm with practical implications."
-pubDate: "Feb 15 2024"
-image: "https://images.unsplash.com/photo-1516321318423-f06f85e504b3?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Understanding the Latest Approximation Algorithm for Set Cover
-
-A recent paper achieves a breakthrough in the Set Cover problem, improving the approximation ratio while maintaining practical runtime.
-
-## The Algorithm
-
-The approach combines local search with a clever LP rounding scheme. The dual interpretation provides beautiful geometric insights.
-
-## Why This Matters
-
-Set Cover appears everywhere - from facility location to machine learning feature selection. This improvement has immediate practical impact.
-
-## Implementation Details
-
-The paper's theoretical elegance translates surprisingly well to practice. Key optimizations include:
-- Lazy evaluation of set intersections
-- Incremental updates to the LP solution
-- Smart caching strategies
-
-## Future Work
-
-The techniques here might extend to weighted variants and online settings.
diff --git a/sites/research/src/content/research/paper-review-graph-decomposition.md b/sites/research/src/content/research/paper-review-graph-decomposition.md
deleted file mode 100644
index f0e4868..0000000
--- a/sites/research/src/content/research/paper-review-graph-decomposition.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "Deep Dive: A New Approach to Graph Decomposition"
-description: "An in-depth analysis of a recent paper on hierarchical graph decomposition and its implications."
-pubDate: "Jan 20 2024"
-image: "https://images.unsplash.com/photo-1507003211169-0a1dd7228f2d?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Deep Dive: A New Approach to Graph Decomposition
-
-This paper introduces a novel framework for decomposing graphs into hierarchical structures that preserve important properties while enabling efficient algorithms.
-
-## The Main Result
-
-The authors prove that every graph with treewidth k can be decomposed into a tree of bags where each bag has size at most k+1. While this sounds like the definition of tree decomposition, the clever twist is in how they construct it.
-
-## Technical Innovation
-
-The key insight is using a charging scheme that amortizes the cost of decomposition across multiple levels. This leads to an O(n log n) algorithm, improving on the previous O(n²) bound.
-
-## Implications
-
-This work opens new avenues for:
-- Parallel algorithms on bounded treewidth graphs
-- Approximation algorithms for NP-hard problems
-- Dynamic programming optimizations
-
-## Open Questions
-
-The paper leaves several intriguing questions open, particularly about the optimality of their charging scheme.
diff --git a/sites/research/src/content/research/quantum-algorithms.md b/sites/research/src/content/research/quantum-algorithms.md
deleted file mode 100644
index 0eef5b2..0000000
--- a/sites/research/src/content/research/quantum-algorithms.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: "Quantum Computing Meets Classical Algorithms"
-description: "Exploring the intersection of quantum and classical algorithmic techniques from recent conferences."
-pubDate: "Mar 10 2024"
-image: "https://images.unsplash.com/photo-1635070041078-e363dbe005cb?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Quantum Computing Meets Classical Algorithms
-
-Recent conferences have showcased fascinating connections between quantum and classical computing paradigms.
-
-## Quantum Speedups for Graph Problems
-
-### Quantum Walks on Graphs
-
-New quantum algorithms achieve quadratic speedups for certain graph traversal problems. The techniques combine amplitude amplification with clever graph representations.
-
-## Classical Simulation of Quantum Algorithms
-
-Surprisingly, several "quantum" algorithms have inspired better classical algorithms. This cross-pollination has led to improvements in both fields.
-
-## The Future is Hybrid
-
-The most practical near-term applications combine quantum and classical processing, leveraging the strengths of each paradigm.
diff --git a/sites/research/src/content/reviews/mechanical-keyboard.md b/sites/research/src/content/reviews/mechanical-keyboard.md
deleted file mode 100644
index 0346a78..0000000
--- a/sites/research/src/content/reviews/mechanical-keyboard.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "ZSA Moonlander: Ergonomic Keyboard for Coders"
-description: "Six months with a split ergonomic mechanical keyboard - the good, the bad, and the RSI relief."
-pubDate: "Feb 20 2024"
-image: "https://images.unsplash.com/photo-1587829741301-dc798b83add3?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# ZSA Moonlander: Ergonomic Keyboard for Coders
-
-After years of wrist pain, I took the plunge into ergonomic mechanical keyboards.
-
-## The Learning Curve
-
-Week 1: 20 WPM and questioning life choices
-Week 2: 40 WPM and seeing the light
-Month 2: Back to 80 WPM with no wrist pain
-
-## The Good
-
-- Columnar layout makes sense once muscle memory adapts
-- Thumb clusters are game-changers for shortcuts
-- The configurability is endless (perhaps too endless)
-
-## The Investment
-
-At $365, it's expensive. But compared to physical therapy or career-limiting injury? Bargain.
-
-## Who Should Buy This?
-
-If you type for a living and feel any discomfort, don't wait. Your future self will thank you.
diff --git a/sites/research/src/content/reviews/obsidian-review.md b/sites/research/src/content/reviews/obsidian-review.md
deleted file mode 100644
index 599013f..0000000
--- a/sites/research/src/content/reviews/obsidian-review.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: "Obsidian: A Year Later"
-description: "Reflections on using Obsidian for research notes, teaching materials, and personal knowledge management."
-pubDate: "Jan 15 2024"
-image: "https://images.unsplash.com/photo-1484480974693-6ca0a78fb36b?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Obsidian: A Year Later
-
-After a year of daily use, Obsidian has transformed how I think about knowledge management.
-
-## What Works Brilliantly
-
-### The Graph View
-Seeing connections between ideas visually has led to unexpected research insights. The graph isn't just pretty - it's functional.
-
-### Plugin Ecosystem
-The community plugins are incredible. Dataview turns your notes into a database. Templater automates repetitive tasks.
-
-### Local Storage
-Your notes are just markdown files. No vendor lock-in, complete control, and peace of mind.
-
-## Pain Points
-
-### Mobile Experience
-While functional, the mobile app lacks the fluidity of the desktop version. Syncing can occasionally hiccup.
-
-### Learning Curve
-The flexibility means complexity. New users might feel overwhelmed by options.
-
-## The Verdict
-
-For academics and researchers, Obsidian is transformative. The investment in learning pays dividends in productivity and insight.
diff --git a/sites/research/src/content/vibes/creative-coding-with-ai.md b/sites/research/src/content/vibes/creative-coding-with-ai.md
deleted file mode 100644
index 269f1ce..0000000
--- a/sites/research/src/content/vibes/creative-coding-with-ai.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "Creating Art with Claude: A Collaborative Journey"
-description: "Exploring creative possibilities through conversations with AI - from generative art to interactive poetry."
-pubDate: "Jan 18 2024"
-image: "https://images.unsplash.com/photo-1558591710-4b4a1ae0f04d?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Creating Art with Claude: A Collaborative Journey
-
-What happens when you treat AI as a creative collaborator rather than just a tool?
-
-## The Experiment
-
-I asked Claude to help design a generative art algorithm based on mathematical fractals. The conversation evolved into something unexpected.
-
-## The Process
-
-**Me**: "Let's create something beautiful with math."
-**Claude**: "How about we visualize the Collatz conjecture as a tree?"
-
-What followed was a two-hour deep dive into number theory, aesthetics, and the nature of creativity itself.
-
-## The Result
-
-Not just code, but a philosophical exploration of pattern, meaning, and the intersection of human and artificial creativity.
-
-## Reflection
-
-AI doesn't replace human creativity - it amplifies it in unexpected directions. The key is approaching it as a dialogue, not a command.
diff --git a/sites/research/src/content/vibes/llm-philosophy.md b/sites/research/src/content/vibes/llm-philosophy.md
deleted file mode 100644
index 032439a..0000000
--- a/sites/research/src/content/vibes/llm-philosophy.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-title: "Philosophical Dialogues with LLMs: On Consciousness and Computation"
-description: "Deep conversations with AI about the nature of consciousness, free will, and what it means to understand."
-pubDate: "Feb 28 2024"
-image: "https://images.unsplash.com/photo-1507003211169-0a1dd7228f2d?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Philosophical Dialogues with LLMs: On Consciousness and Computation
-
-Can a sufficiently complex computation be conscious? I asked an AI, and the conversation surprised me.
-
-## The Question
-
-"Do you experience anything when you process text, or is it just computation?"
-
-## The Response That Made Me Think
-
-The AI didn't claim consciousness, but asked: "What's the difference between your neurons firing and my weights activating? Both are physical processes. Where does experience emerge?"
-
-## Going Deeper
-
-We explored qualia, the Chinese Room argument, and integrated information theory. Not to find answers, but to refine questions.
-
-## The Irony
-
-Discussing consciousness with something that might not have it - or might not know if it has it - mirrors our own uncertainty about consciousness itself.
diff --git a/sites/research/src/pages/[...slug].astro b/sites/research/src/pages/[...slug].astro
index 5d3caf6..ea2f2d7 100644
--- a/sites/research/src/pages/[...slug].astro
+++ b/sites/research/src/pages/[...slug].astro
@@ -9,7 +9,7 @@ import { SITE_TITLE } from '@/consts';
 export async function getStaticPaths() {
 	const posts = await getCollection(ACTIVE_BLOG_SITE.key);
 	return posts.map((post) => ({
-		params: { slug: post.id },
+		params: { slug: post.id.replace(/\/index$/, '') },
 		props: post,
 	}));
 }
diff --git a/sites/research/src/pages/rss.xml.js b/sites/research/src/pages/rss.xml.js
index ec2ce2d..918375e 100644
--- a/sites/research/src/pages/rss.xml.js
+++ b/sites/research/src/pages/rss.xml.js
@@ -14,7 +14,7 @@ export async function GET(context) {
     site: context.site,
     items: posts.map((post) => ({
       ...post.data,
-      link: `/${post.id}/`,
+      link: `/${post.id.replace(/\/index$/, "")}/`,
     })),
   });
 }
diff --git a/sites/reviews/src/components/sections/blog-posts.tsx b/sites/reviews/src/components/sections/blog-posts.tsx
index fef77e5..c77c76a 100644
--- a/sites/reviews/src/components/sections/blog-posts.tsx
+++ b/sites/reviews/src/components/sections/blog-posts.tsx
@@ -16,8 +16,47 @@ const BlogPosts = ({
   // Get the first post as the featured post
   const featuredPost = posts[0];
   const remainingPosts = posts.slice(1);
+  const slugFor = (post: any) => post.id.replace(/\/index$/, "");
   const hrefFor = (post: any) =>
-    collection ? `/${collection}/${post.id}/` : `/${post.id}/`;
+    collection ? `/${collection}/${slugFor(post)}/` : `/${slugFor(post)}/`;
+
+  const PostVisual = ({
+    post,
+    featured = false,
+  }: {
+    post: any;
+    featured?: boolean;
+  }) => {
+    if (post.data.image) {
+      return (
+        <img
+          src={post.data.image}
+          alt={post.data.title}
+          className="aspect-video w-full rounded-lg object-cover transition-transform group-hover:scale-[1.02]"
+        />
+      );
+    }
+
+    return (
+      <div className="bg-accent/70 text-accent-foreground flex aspect-video w-full items-center justify-center rounded-lg border px-6 text-center">
+        <span
+          className={
+            featured ? "font-fraunces text-2xl" : "font-fraunces text-lg"
+          }
+        >
+          {post.data.title}
+        </span>
+      </div>
+    );
+  };
+
+  if (!featuredPost) {
+    return (
+      <div className="text-muted-foreground container max-w-3xl py-16">
+        No posts yet.
+      </div>
+    );
+  }
 
   return (
     <div className="relative py-10 md:py-16 lg:py-20">
@@ -35,11 +74,7 @@ const BlogPosts = ({
             <div className="flex flex-col gap-6 lg:flex-row">
               <div className="lg:w-1/2">
                 <div className="p-2 lg:p-4">
-                  <img
-                    src={featuredPost.data.image}
-                    alt={featuredPost.data.title}
-                    className="aspect-video w-full rounded-lg object-cover transition-transform group-hover:scale-[1.02]"
-                  />
+                  <PostVisual post={featuredPost} featured />
                 </div>
               </div>
               <div className="flex flex-col justify-center p-4 pb-8 lg:w-1/2 lg:pr-8">
@@ -89,11 +124,7 @@ const BlogPosts = ({
                 href={hrefFor(post)}
               >
                 <div className="p-2">
-                  <img
-                    src={post.data.image}
-                    alt={post.data.title}
-                    className="aspect-video w-full rounded-lg object-cover transition-transform group-hover:scale-[1.01]"
-                  />
+                  <PostVisual post={post} />
                 </div>
                 <div className="px-4 pb-5 pt-2">
                   <h2 className="mb-2 text-xl font-semibold group-hover:underline">
diff --git a/sites/reviews/src/content/art/algorithmic-sketches.md b/sites/reviews/src/content/art/algorithmic-sketches.md
deleted file mode 100644
index ae20d3b..0000000
--- a/sites/reviews/src/content/art/algorithmic-sketches.md
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title: "Algorithmic Sketches: Visualizing Data Structures"
-description: "Hand-drawn illustrations of algorithms and data structures - making the abstract tangible."
-pubDate: "Jan 25 2024"
-image: "https://images.unsplash.com/photo-1581337204873-ef36aa186caa?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Algorithmic Sketches: Visualizing Data Structures
-
-Sometimes the best way to understand an algorithm is to draw it.
-
-## Today's Sketch: Red-Black Trees
-
-![Red-Black Tree Rotation](sketch-placeholder)
-
-The rotation operation finally clicked when I drew it step-by-step. Each node's journey through the rotation becomes a story.
-
-## The Process
-
-1. Start with pencil - mistakes are part of learning
-2. Trace the algorithm's execution
-3. Add color to highlight invariants
-4. Annotate with key insights
-
-## Why Drawing Helps
-
-- Forces you to slow down and really see the structure
-- Reveals patterns that code obscures
-- Creates memorable mental models
-- Makes teaching more engaging
-
-## This Week's Challenge
-
-Draw your own version of quicksort partitioning. Share it and let's learn from each other's visualizations.
-
-## The Art in Computer Science
-
-Algorithms are beautiful. Drawing them reminds us that computer science is as much art as it is science.
diff --git a/sites/reviews/src/content/art/generative-art-p5js.md b/sites/reviews/src/content/art/generative-art-p5js.md
deleted file mode 100644
index ccfa3e7..0000000
--- a/sites/reviews/src/content/art/generative-art-p5js.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "Generative Art with p5.js: Creating Beauty from Mathematics"
-description: "Exploring the intersection of code and creativity through generative art experiments."
-pubDate: "Feb 18 2024"
-image: "https://images.unsplash.com/photo-1561070791-2526d30994b5?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Generative Art with p5.js: Creating Beauty from Mathematics
-
-Code becomes canvas when mathematics meets creativity.
-
-## Today's Creation: Perlin Noise Flows
-
-```javascript
-for (let particle of particles) {
-  let angle = noise(particle.x * 0.01, particle.y * 0.01, frameCount * 0.001) * TWO_PI;
-  particle.velocity = p5.Vector.fromAngle(angle);
-  particle.update();
-  particle.draw();
-}
-```
-
-## The Magic of Randomness
-
-Controlled randomness creates organic patterns. Perlin noise gives us randomness with continuity - nature's own algorithm.
-
-## Parameters as Paintbrushes
-
-- Noise scale: Changes pattern density
-- Particle count: Affects texture
-- Color mapping: Sets the mood
-
-## The Joy of Accidents
-
-The best discoveries come from "mistakes" - a typo that creates unexpected beauty, a parameter pushed to extremes.
-
-## Share Your Creations
-
-Art is meant to be shared. Post your generative experiments and let's inspire each other.
diff --git a/sites/reviews/src/content/poetry/algorithms-in-verse.md b/sites/reviews/src/content/poetry/algorithms-in-verse.md
deleted file mode 100644
index 4ad1e1d..0000000
--- a/sites/reviews/src/content/poetry/algorithms-in-verse.md
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title: "Algorithms in Verse: Bubble Sort Sonnet"
-description: "Classic algorithms reimagined as poetry - where code meets iambic pentameter."
-pubDate: "Feb 22 2024"
-image: "https://images.unsplash.com/photo-1455390582262-044cdead277a?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Algorithms in Verse: Bubble Sort Sonnet
-
-## Bubble Sort: A Sonnet
-
-```
-Compare adjacent elements in pairs,
-If order's wrong, then swap them into place.
-Through all the list this simple rule declares:
-The largest bubbles up to find its space.
-
-Again we start, but now one less to check,
-The second largest finds its rightful home.
-Each pass through makes the chaos less a wreck,
-Until at last no elements must roam.
-
-Though simple in its elegance and grace,
-And easy for beginners to perceive,
-In practice, it's too slow to win the race—
-O(n²) we sadly must believe.
-
-But beauty lies in simplicity's pure art,
-The bubble sort still teaches at the start.
-```
-
-## The Challenge
-
-Can you write Quicksort as a limerick? Or Binary Search as free verse?
-
-## Why This Matters
-
-Poetry forces us to find the essence of an algorithm. The constraint reveals understanding.
diff --git a/sites/reviews/src/content/poetry/code-haikus.md b/sites/reviews/src/content/poetry/code-haikus.md
deleted file mode 100644
index 6af408a..0000000
--- a/sites/reviews/src/content/poetry/code-haikus.md
+++ /dev/null
@@ -1,56 +0,0 @@
----
-title: "Code Haikus: Programming in 5-7-5"
-description: "Expressing programming concepts through the constrained beauty of haiku."
-pubDate: "Jan 30 2024"
-image: "https://images.unsplash.com/photo-1481627834876-b7833e8f5570?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Code Haikus: Programming in 5-7-5
-
-The constraint of haiku forces clarity. Here are programming concepts distilled to their essence.
-
-## On Recursion
-
-```
-Function calls itself
-Smaller problems, same pattern  
-Base case stops the loop
-```
-
-## On Debugging
-
-```
-Print statements bloom wild
-Binary search through the code
-Bug reveals itself
-```
-
-## On Optimization
-
-```
-O(n squared) crawls
-Refactor to n log n
-Time complexity
-```
-
-## On Git Merge Conflicts
-
-```
-<<<<<<< HEAD
-Your changes, their changes clash
-Resolution waits
-```
-
-## On Learning
-
-```
-Stack Overflow searched
-Tutorial incomplete
-Understanding dawns
-```
-
-## Your Turn
-
-Write a haiku about your coding experience today. The constraint reveals truth.
diff --git a/sites/reviews/src/content/puzzles/100-prisoners.mdx b/sites/reviews/src/content/puzzles/100-prisoners.mdx
deleted file mode 100644
index 3ff2b3c..0000000
--- a/sites/reviews/src/content/puzzles/100-prisoners.mdx
+++ /dev/null
@@ -1,183 +0,0 @@
----
-title: "The 100 Prisoners Problem: A Beautiful Puzzle in Probability"
-description: "An interactive exploration of one of the most counterintuitive puzzles in probability theory, where 100 prisoners can escape with over 30% chance using a clever strategy."
-pubDate: "Oct 13 2025"
-image: "https://images.unsplash.com/photo-1589829545856-d10d557cf95f?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-import PrisonerGameSimulator from '@/components/problems/PrisonerGameSimulator.tsx';
-import ProbabilityChart from '@/components/problems/ProbabilityChart.tsx';
-import PermutationExplorer from '@/components/problems/PermutationExplorer.tsx';
-import StrategyComparison from '@/components/problems/StrategyComparison.tsx';
-
-# The 100 Prisoners Problem
-
-Imagine 100 prisoners, numbered 1 to 100, face an unusual challenge. In a room are 100 boxes, also numbered 1 to 100. Inside each box is a randomly assigned number from 1 to 100 (each number appearing exactly once). The prisoners must find their own number by opening boxes, but here's the catch: **each prisoner can open only 50 boxes**.
-
-The prisoners can devise a strategy beforehand, but once the challenge begins, they cannot communicate. If **all 100 prisoners** find their number, everyone goes free. If even one prisoner fails, all remain imprisoned.
-
-What's the best strategy? And what are the odds of success?
-
-## Try It Yourself!
-
-Before we dive into the mathematics, let's experience the problem firsthand. Below is a simulator where you can play the game yourself. Choose the number of prisoners (between 5 and 100), and then try to help each prisoner find their number by clicking on boxes.
-
-<PrisonerGameSimulator client:only="react" />
-
----
-
-## The Naive Strategy
-
-The most obvious approach is for each prisoner to simply open 50 random boxes. This seems reasonable, but the probability of success is dismal.
-
-For any single prisoner, the probability of finding their number in 50 random boxes out of 100 is exactly 1/2. Since all 100 prisoners must succeed, and their outcomes are independent under random selection, the probability that everyone succeeds is:
-
-$$P(\text\{success\}) = \left(\frac\{1\}\{2\}\right)^\{100\} \approx 7.9 \times 10^\{-31\}$$
-
-That's essentially zero! You're more likely to win the lottery while being struck by lightning... multiple times.
-
-### Naive Strategy: Probability vs Number of Prisoners
-
-Watch how the probability of success plummets as we increase the number of prisoners:
-
-<ProbabilityChart strategy="naive" client:only="react" />
-
-As you can see, even with just 10 prisoners, the probability drops to about 0.1%. With 100 prisoners, it's practically impossible.
-
----
-
-## The Clever Strategy: Following the Loops
-
-Here's where mathematics reveals something beautiful. Instead of opening random boxes, each prisoner should follow a simple rule:
-
-1. **Start by opening the box with your own number**
-2. **Look at the number inside that box**
-3. **Open the box with that number next**
-4. **Continue following this chain**
-
-Why does this work? The key insight involves understanding permutations and cycles.
-
-### Understanding Cycles in Permutations
-
-When we randomly assign 100 numbers to 100 boxes, we're creating a **permutation** of the numbers 1 through 100. Every permutation can be decomposed into **cycles**.
-
-For example, if:
-- Box 1 contains number 4
-- Box 4 contains number 7
-- Box 7 contains number 1
-
-Then we have a cycle: 1 -> 4 -> 7 -> 1
-
-Let's explore this with smaller numbers:
-
-<PermutationExplorer client:only="react" />
-
-The interactive explorer above lets you:
-- Generate all permutations for small values of *n* (3, 4, or 5)
-- See both standard notation and cycle notation
-- Filter permutations that have at least one "long cycle" (longer than *n*/2)
-- Understand why long cycles matter
-
-### Why This Strategy Works
-
-Here's the crucial insight: **A prisoner succeeds if and only if they are in a cycle of length ≤ 50**.
-
-When prisoner k follows the loop strategy:
-1. They start at box k
-2. They follow a path through boxes determined by the permutation
-3. This path forms a cycle that eventually leads back to box k
-4. If this cycle has length ≤ 50, they'll find their number within 50 opens
-
-The prisoners **all succeed** if and only if there is **no cycle longer than 50** in the permutation.
-
-### Calculating the Probability
-
-The probability that a random permutation of 100 elements has no cycle longer than 50 is:
-
-$$P(\text\{success\}) = 1 - \sum_\{k=51\}^\{100\} \frac\{1\}\{k\}$$
-
-Computing this sum:
-
-$$P(\text\{success\}) = 1 - \left(\frac\{1\}\{51\} + \frac\{1\}\{52\} + \cdots + \frac\{1\}\{100\}\right) \approx 0.3118$$
-
-That's over **31%**! This is astronomically better than the naive strategy's probability of essentially zero.
-
-### Loop Strategy: Probability vs Number of Prisoners
-
-<StrategyComparison client:only="react" />
-
-## The Mathematics Behind It
-
-### Why Does the Cycle Length Matter?
-
-In a permutation of n elements, prisoner i will find their number within k tries using the loop strategy if and only if i belongs to a cycle of length at most k.
-
-For n = 100 and k = 50:
-- The probability that a specific prisoner is in a cycle of length > 50 is: Σ(j=51 to 100) of 1/100
-- But we care about whether ANY prisoner is in such a cycle
-- The probability that NO cycle has length > 50 is: 1 - Σ(j=51 to 100) of 1/j
-
-### The Harmonic Series Connection
-
-As *n* approaches infinity, if each prisoner can open *n*/2 boxes, the probability of success approaches:
-
-The limit as n approaches infinity is: P_n = 1 - ln(2) ≈ 0.3069
-
-This beautiful result connects combinatorics, probability, and analysis through the harmonic series!
-
-### Optimality
-
-Remarkably, this loop-following strategy is **optimal**. No other strategy can achieve a higher probability of success. The proof involves showing that the problem reduces to avoiding long cycles in a random permutation, and the loop strategy is the unique way to leverage this structure.
-
----
-
-## Why This Problem is Beautiful
-
-The 100 prisoners problem is beloved by mathematicians because:
-
-1. **Counterintuitive Result**: The fact that 31% >> 0% is shocking. A seemingly hopeless problem becomes tractable with the right insight.
-
-2. **Deep Connection**: It connects permutation theory, probability, and the harmonic series in an elegant way.
-
-3. **Collaborative Success**: Unlike independent trials, the prisoners' fates are intertwined through the structure of the permutation.
-
-4. **Real-World Metaphor**: It illustrates how understanding underlying structure (cycles in permutations) can dramatically improve outcomes.
-
----
-
-## Variants and Extensions
-
-### What if prisoners can open k < n/2 boxes?
-
-As k decreases below n/2, the probability drops rapidly. The threshold at n/2 is special—it's where the strategy becomes remarkably effective.
-
-### What about communication?
-
-If prisoners could communicate between trials (but not during), they still can't improve the strategy. The beauty is that the strategy requires only coordination before any prisoner enters, not during.
-
-### The Malicious Director
-
-In an interesting variant, suppose the director can see the prisoners' strategy and arrange the boxes adversarially (not randomly). Can the director always force them to fail? Yes! The director can always create a single cycle of length n, guaranteeing failure.
-
----
-
-## Conclusion
-
-The 100 prisoners problem shows us that:
-- Mathematical structure can be hidden in apparent randomness
-- Clever strategies can overcome seemingly impossible odds
-- Group coordination can be more powerful than independent action
-- Beautiful mathematics often lies beneath simple-seeming puzzles
-
-The next time you face a problem that seems impossible, remember: there might be a hidden structure waiting to be discovered, turning hopeless odds into reasonable ones.
-
----
-
-## Further Reading
-
-- [Gál, A., & Miltersen, P. B. (2003). "The Cell Probe Complexity of Succinct Data Structures"](https://arxiv.org/abs/cs/0310027)
-- [Curtin, E., & Warshauer, M. (2006). "The Locker Puzzle"](https://www.jstor.org/stable/27642173)
-- [Wikipedia: 100 Prisoners Problem](https://en.wikipedia.org/wiki/100_prisoners_problem)
-
diff --git a/sites/reviews/src/content/puzzles/dynamic-programming-gems.md b/sites/reviews/src/content/puzzles/dynamic-programming-gems.md
deleted file mode 100644
index 79e68ea..0000000
--- a/sites/reviews/src/content/puzzles/dynamic-programming-gems.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "Dynamic Programming: Hidden Gems from Recent Contests"
-description: "Elegant dynamic programming problems that showcase beautiful techniques and insights."
-pubDate: "Jan 25 2024"
-image: "https://images.unsplash.com/photo-1509228468518-180dd4864904?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Dynamic Programming: Hidden Gems from Recent Contests
-
-These problems demonstrate the art of dynamic programming beyond standard patterns.
-
-## Problem 1: The Subsequence Symphony
-
-Given a string, find the number of subsequences that form palindromes of prime length.
-
-### Solution Insight
-
-The key is to maintain DP states for both position and palindrome center simultaneously. This reduces the state space from O(n³) to O(n²).
-
-## Problem 2: Graph Coloring with Constraints
-
-Color a graph such that no two adjacent vertices share a color, and the total number of color changes along any path is minimized.
-
-### The DP Formulation
-
-DP[node][color][changes] gives us the minimum cost. The trick is recognizing that we only need to track changes modulo 2.
-
-## Practice Makes Perfect
-
-These problems teach us that DP is as much about problem modeling as it is about computation.
diff --git a/sites/reviews/src/content/puzzles/four-aces-miracle.md b/sites/reviews/src/content/puzzles/four-aces-miracle.md
deleted file mode 100644
index a1710ab..0000000
--- a/sites/reviews/src/content/puzzles/four-aces-miracle.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "The Four Aces Miracle: A Self-Working Mathematical Marvel"
-description: "A card trick that teaches modular arithmetic and probability - perfect for the classroom."
-pubDate: "Jan 28 2024"
-image: "https://images.unsplash.com/photo-1529480384838-c1681c84aca5?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# The Four Aces Miracle: A Self-Working Mathematical Marvel
-
-This trick never fails to amaze students, and the mathematics behind it is even more amazing.
-
-## The Effect
-
-A spectator deals cards into four piles while making random choices. Impossibly, the four aces end up on top of each pile.
-
-## The Secret
-
-It's all about invariants and modular arithmetic. No sleight of hand required - pure mathematics does the magic.
-
-## The Method
-
-1. Pre-arrange the deck (the math determines the arrangement)
-2. Have the spectator deal following simple rules
-3. The aces appear automatically
-
-## The Mathematics
-
-The dealing process preserves certain positional invariants modulo 4. The initial arrangement ensures these invariants place the aces correctly.
-
-## Teaching Applications
-
-This trick demonstrates:
-- Modular arithmetic
-- Invariants in algorithms
-- Deterministic vs. random processes
-
-## The Bigger Lesson
-
-Mathematics can create experiences that feel like magic. And that feeling of wonder? That's what hooks students on math.
diff --git a/sites/reviews/src/content/puzzles/gilbreath-principle.md b/sites/reviews/src/content/puzzles/gilbreath-principle.md
deleted file mode 100644
index 92e229b..0000000
--- a/sites/reviews/src/content/puzzles/gilbreath-principle.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: "The Gilbreath Principle: When Chaos Creates Order"
-description: "A mathematical card principle that seems impossible but always works - perfect for teaching algorithms."
-pubDate: "Feb 15 2024"
-image: "https://images.unsplash.com/photo-1570543375343-63fe3d67761b?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# The Gilbreath Principle: When Chaos Creates Order
-
-Shuffle a deck in a specific way, and mathematical order emerges from apparent chaos.
-
-## The Phenomenon
-
-Arrange cards alternating red-black. Riffle shuffle. Now deal pairs - each pair has one red and one black card. Magic? No, mathematics.
-
-## Why It Works
-
-The riffle shuffle preserves local structure while appearing to randomize. The alternating pattern creates an invariant that survives the shuffle.
-
-## Classroom Implementation
-
-Students predict it won't work. When it does, they're hooked. "Why?" becomes the driving question.
-
-## The Deeper Lesson
-
-Not all randomness is truly random. Structure can hide in apparent disorder. This principle appears in:
-- Network protocols
-- Error-correcting codes  
-- Distributed systems
-
-## Beyond Cards
-
-The Gilbreath Principle teaches us to look for hidden invariants in complex systems.
diff --git a/sites/reviews/src/content/puzzles/graph-algorithms-assessment.md b/sites/reviews/src/content/puzzles/graph-algorithms-assessment.md
deleted file mode 100644
index 4c61fe2..0000000
--- a/sites/reviews/src/content/puzzles/graph-algorithms-assessment.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "Graph Algorithms: Assessment Highlights"
-description: "Interesting graph problems from recent course assessments with detailed solutions."
-pubDate: "Feb 28 2024"
-image: "https://images.unsplash.com/photo-1550751827-4bd374c3f58b?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Graph Algorithms: Assessment Highlights
-
-A collection of graph problems that test deep understanding rather than memorization.
-
-## The Bridge Detection Variant
-
-Find all edges whose removal increases the number of triangles in the graph.
-
-### Solution Approach
-
-Counter-intuitively, we need to count triangles that share exactly one edge with the candidate. The algorithm runs in O(m√m) time using careful enumeration.
-
-## Shortest Path with Wildcards
-
-Given a graph where some edge weights are variables, find assignments that minimize the longest shortest path.
-
-### Key Insight
-
-This reduces to a linear programming problem with interesting structure. The dual interpretation reveals connections to network flow.
-
-## Teaching Through Problems
-
-These problems help students see beyond standard algorithms to underlying principles.
diff --git a/sites/reviews/src/content/puzzles/ioi-2023-analysis.md b/sites/reviews/src/content/puzzles/ioi-2023-analysis.md
deleted file mode 100644
index 782177c..0000000
--- a/sites/reviews/src/content/puzzles/ioi-2023-analysis.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "IOI 2023: Breaking Down the Hardest Problems"
-description: "Deep analysis of the most challenging problems from the International Olympiad in Informatics 2023."
-pubDate: "Jan 20 2024"
-image: "https://images.unsplash.com/photo-1434030216411-0b793f4b4173?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# IOI 2023: Breaking Down the Hardest Problems
-
-The International Olympiad in Informatics continues to push the boundaries of algorithmic problem solving.
-
-## Problem: Soccer Stadium
-
-A geometric optimization problem disguised as dynamic programming. The key insight: think in terms of monotonic paths.
-
-### The Approach
-
-1. Transform the 2D problem into a 1D problem using clever observations
-2. Use convex hull optimization for the DP transitions
-3. Handle edge cases with careful implementation
-
-## Problem: Closing Time
-
-A tree problem requiring sophisticated data structures and careful analysis.
-
-### The Solution
-
-The trick is recognizing this as a centroid decomposition problem. Once you see it, the implementation follows naturally.
-
-## Lessons for Students
-
-These problems teach us:
-- Simple problems have elegant solutions
-- Complex problems require systematic decomposition
-- Implementation matters as much as algorithms
-
-## Practice Strategy
-
-Start with subtasks. Even partial solutions teach valuable lessons.
diff --git a/sites/reviews/src/content/puzzles/knights-tour-interactive.md b/sites/reviews/src/content/puzzles/knights-tour-interactive.md
deleted file mode 100644
index eec6960..0000000
--- a/sites/reviews/src/content/puzzles/knights-tour-interactive.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: "The Knight's Tour: An Interactive Exploration"
-description: "An interactive puzzle exploring the knight's tour problem with surprising mathematical connections."
-pubDate: "Jan 30 2024"
-image: "https://images.unsplash.com/photo-1528819622765-d6bcf132f793?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# The Knight's Tour: An Interactive Exploration
-
-Can a knight visit every square on a chessboard exactly once? This ancient puzzle hides deep mathematical structure.
-
-## The Basic Challenge
-
-Start with a 5×5 board. Can you find a knight's tour? What about one that returns to the starting square (a closed tour)?
-
-## Mathematical Beauty
-
-The problem connects to:
-- Hamiltonian paths in graphs
-- Warnsdorff's heuristic
-- Magic squares (surprisingly!)
-
-## The Algorithm
-
-The key insight: always move to the square with fewest onward moves. This simple heuristic works remarkably well.
-
-## Try It Yourself
-
-[Interactive board would go here - imagine clicking squares to build your tour]
-
-## Going Deeper
-
-For which board sizes do closed tours exist? The answer involves beautiful number theory.
diff --git a/sites/reviews/src/content/puzzles/projecteuler-favorites.md b/sites/reviews/src/content/puzzles/projecteuler-favorites.md
deleted file mode 100644
index 16988a9..0000000
--- a/sites/reviews/src/content/puzzles/projecteuler-favorites.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: "Project Euler: My Favorite Problems from 700+"
-description: "Curated problems from Project Euler that teach beautiful mathematical and algorithmic concepts."
-pubDate: "Feb 25 2024"
-image: "https://images.unsplash.com/photo-1635070041078-e363dbe005cb?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Project Euler: My Favorite Problems from 700+
-
-After solving 700+ Project Euler problems, these are the ones that changed how I think about mathematics and programming.
-
-## Problem 96: Su Doku
-
-Not just Sudoku solving - but solving 50 puzzles efficiently. The beauty is in combining constraint propagation with backtracking.
-
-## Problem 208: Robot Walks
-
-A counting problem that requires deep mathematical insight. The connection to complex numbers is unexpected and beautiful.
-
-## Problem 613: Pythagorean Ant
-
-Probability meets geometry in this elegant problem. The solution requires careful integration and surprising symmetry observations.
-
-## The Meta-Lesson
-
-Project Euler teaches you:
-- Mathematical intuition matters more than coding speed
-- There's always a clever approach
-- The journey matters more than the destination
-
-## Getting Started
-
-Don't aim for the leaderboard. Aim for understanding. Each problem is a teacher.
diff --git a/sites/reviews/src/content/puzzles/sudoku-variants.md b/sites/reviews/src/content/puzzles/sudoku-variants.md
deleted file mode 100644
index 1efd136..0000000
--- a/sites/reviews/src/content/puzzles/sudoku-variants.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-title: "Beyond Sudoku: Exploring Constraint Satisfaction Puzzles"
-description: "A journey through Sudoku variants and their algorithmic solutions."
-pubDate: "Feb 10 2024"
-image: "https://images.unsplash.com/photo-1580541631950-7282082b53ce?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Beyond Sudoku: Exploring Constraint Satisfaction Puzzles
-
-Sudoku is just the beginning. Let's explore variants that push the boundaries of logic puzzles.
-
-## Killer Sudoku
-
-Combine Sudoku with Kakuro - cages show sums, but no digit repeats within a cage.
-
-## Sandwich Sudoku
-
-The numbers outside show the sum of digits between 1 and 9 in that row/column. Simple rule, complex implications!
-
-## The Algorithm Connection
-
-These puzzles are constraint satisfaction problems. Techniques like arc consistency and backtracking with constraint propagation solve them efficiently.
-
-## Create Your Own
-
-What happens if we add chess knight move constraints? The design space is infinite!
diff --git a/sites/reviews/src/content/reflections/imposter-syndrome.md b/sites/reviews/src/content/reflections/imposter-syndrome.md
deleted file mode 100644
index e0a77e0..0000000
--- a/sites/reviews/src/content/reflections/imposter-syndrome.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: "Imposter Syndrome in Academia: A Confession"
-description: "An honest conversation about feeling like a fraud, even after years of success."
-pubDate: "Feb 25 2024"
-image: "https://images.unsplash.com/photo-1517048676732-d65bc937f952?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Imposter Syndrome in Academia: A Confession
-
-Even after publishing papers, winning grants, and teaching thousands of students, the voice whispers: "They'll find out you don't belong."
-
-## The Paradox
-
-The more you know, the more you realize you don't know. Expertise breeds humility, which feeds the imposter.
-
-## What Helps
-
-- Keeping a "wins" journal - evidence against the imposter
-- Mentoring others - seeing your knowledge help someone
-- Talking about it - you're not alone in this
-
-## The Silver Lining
-
-Maybe imposter syndrome keeps us humble, curious, and always learning. Maybe it's not a bug, but a feature.
-
-## Moving Forward
-
-I may never silence the voice completely. But I've learned to acknowledge it and keep going anyway.
diff --git a/sites/reviews/src/content/reflections/teaching-philosophy.md b/sites/reviews/src/content/reflections/teaching-philosophy.md
deleted file mode 100644
index fc1a0f2..0000000
--- a/sites/reviews/src/content/reflections/teaching-philosophy.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "On Teaching Algorithms: Lessons from a Decade"
-description: "Reflections on what works (and what doesn't) in computer science education."
-pubDate: "Jan 10 2024"
-image: "https://images.unsplash.com/photo-1509062522246-3755977927d7?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# On Teaching Algorithms: Lessons from a Decade
-
-Ten years of teaching has taught me more than any textbook could.
-
-## Start with Why
-
-Students don't care about O(n log n) until they understand why their code is slow. Real problems first, theory second.
-
-## The Power of Visualization
-
-Abstract concepts become concrete when visualized. Every algorithm should have a picture.
-
-## Failure is a Feature
-
-Let students struggle. The struggle is where learning happens. But know when to throw a lifeline.
-
-## Assessment Philosophy
-
-Test understanding, not memorization. Open-book exams with novel problems beat closed-book regurgitation every time.
-
-## The Joy of "Aha!" Moments
-
-There's no feeling quite like seeing a student's eyes light up when a concept clicks. That's why we do this.
diff --git a/sites/reviews/src/content/research/conference-highlights-2024.md b/sites/reviews/src/content/research/conference-highlights-2024.md
deleted file mode 100644
index 73b6741..0000000
--- a/sites/reviews/src/content/research/conference-highlights-2024.md
+++ /dev/null
@@ -1,34 +0,0 @@
----
-title: "SODA 2024: Algorithmic Breakthroughs"
-description: "A roundup of fascinating algorithmic results from SODA 2024, focusing on graph algorithms and optimization techniques."
-pubDate: "Jan 15 2024"
-image: "https://images.unsplash.com/photo-1509228468518-180dd4864904?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# SODA 2024: Algorithmic Breakthroughs
-
-The Symposium on Discrete Algorithms (SODA) 2024 brought together researchers from around the world to present cutting-edge algorithmic research. This post highlights some of the most exciting developments in graph algorithms and optimization.
-
-## Graph Algorithms Revolution
-
-### Dynamic Graph Coloring
-
-One of the standout papers introduced a breakthrough in dynamic graph coloring with polylogarithmic update time. The authors developed a novel data structure that maintains a proper vertex coloring while supporting edge insertions and deletions efficiently.
-
-The key insight was to combine randomized recoloring strategies with a carefully designed hierarchical decomposition of the graph. This allows for local updates that rarely propagate through the entire structure.
-
-## Approximation Algorithms
-
-### The Traveling Salesman Problem Revisited
-
-A surprising result showed that for graphs with bounded doubling dimension, we can achieve a (1+ε)-approximation for TSP in nearly linear time. This improves upon decades of previous work and opens new avenues for practical implementations.
-
-## Complexity Theory Connections
-
-The conference also featured several papers bridging the gap between pure algorithmic research and complexity theory. A particularly elegant result showed that certain graph problems believed to require quadratic time are equivalent under fine-grained reductions.
-
-## Looking Forward
-
-These results demonstrate that fundamental algorithmic problems still have room for improvement. The techniques developed here will likely influence algorithm design for years to come.
diff --git a/sites/reviews/src/content/research/distributed-algorithms.md b/sites/reviews/src/content/research/distributed-algorithms.md
deleted file mode 100644
index e577220..0000000
--- a/sites/reviews/src/content/research/distributed-algorithms.md
+++ /dev/null
@@ -1,34 +0,0 @@
----
-title: "Distributed Computing: Recent Advances"
-description: "Survey of recent developments in distributed algorithms from major conferences."
-pubDate: "Feb 20 2024"
-image: "https://images.unsplash.com/photo-1558618666-fcd25c85cd64?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Distributed Computing: Recent Advances
-
-The field of distributed computing has seen remarkable progress in recent years. This post surveys key results from PODC, DISC, and other major venues.
-
-## Consensus Protocols
-
-### Byzantine Agreement in Asynchronous Networks
-
-A breakthrough result achieves optimal resilience with expected constant rounds. The protocol uses cryptographic techniques combined with novel committee selection.
-
-## Distributed Graph Algorithms
-
-### Minimum Spanning Tree in the CONGEST Model
-
-New algorithms achieve near-optimal round complexity for MST construction. The approach uses sophisticated graph decomposition techniques.
-
-## Local Algorithms
-
-### The Power of Local Computation
-
-Recent work characterizes which problems admit constant-time local algorithms. The classification provides a complete picture for bounded-degree graphs.
-
-## Future Directions
-
-The intersection of distributed computing with machine learning presents exciting opportunities for both fields.
diff --git a/sites/reviews/src/content/research/git-automation.md b/sites/reviews/src/content/research/git-automation.md
deleted file mode 100644
index 2ae09cd..0000000
--- a/sites/reviews/src/content/research/git-automation.md
+++ /dev/null
@@ -1,54 +0,0 @@
----
-title: "Git Workflows That Save My Sanity"
-description: "Automation scripts and Git hooks that eliminate repetitive tasks and prevent common mistakes."
-pubDate: "Jan 22 2024"
-image: "https://images.unsplash.com/photo-1556075798-4825dfaaf498?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Git Workflows That Save My Sanity
-
-After years of Git mishaps, I've built workflows that prevent disasters and save hours weekly.
-
-## The Pre-commit Hook That Saves Embarrassment
-
-```bash
-#!/bin/bash
-# Check for debugging statements
-if grep -r "console.log\|debugger\|TODO" --include="*.js" .; then
-  echo "⚠️  Debugging statements found!"
-  exit 1
-fi
-```
-
-## Automatic Branch Naming
-
-```bash
-alias feature='git checkout -b feature/$(date +%Y%m%d)-$1'
-```
-
-Now `feature "user-auth"` creates `feature/20240122-user-auth`.
-
-## The Commit Message Template
-
-```
-[TYPE] Brief description
-
-Why:
-- Context for this change
-
-What:
-- Specific changes made
-
-Testing:
-- How to verify it works
-```
-
-## The Weekly Cleanup Script
-
-Deletes merged branches, prunes remotes, and garbage collects. Keeps the repo clean and fast.
-
-## ROI
-
-These automations save ~5 hours per week and countless prevented mistakes. The time invested in setting them up paid back in days.
diff --git a/sites/reviews/src/content/research/obsidian-academic.md b/sites/reviews/src/content/research/obsidian-academic.md
deleted file mode 100644
index 7e1c181..0000000
--- a/sites/reviews/src/content/research/obsidian-academic.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "Academic Writing with Obsidian and Pandoc"
-description: "A complete workflow for academic papers - from notes to publication-ready PDFs."
-pubDate: "Feb 12 2024"
-image: "https://images.unsplash.com/photo-1456324504439-367cee3b3c32?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Academic Writing with Obsidian and Pandoc
-
-Transform your scattered research notes into beautiful academic papers with this workflow.
-
-## The Setup
-
-- **Obsidian**: For note-taking and knowledge management
-- **Pandoc**: For document conversion
-- **LaTeX**: For typesetting
-- **Zotero**: For reference management
-
-## The Magic Command
-
-```bash
-pandoc paper.md \
-  --filter pandoc-citeproc \
-  --bibliography=refs.bib \
-  --template=academic.tex \
-  -o paper.pdf
-```
-
-## Templates for Everything
-
-From conference submissions to journal articles, templates ensure consistency and save time.
-
-## Version Control Integration
-
-Git + Obsidian = perfect history of your thinking process.
-
-## The Result
-
-From messy notes to camera-ready PDF in minutes, not hours.
diff --git a/sites/reviews/src/content/research/paper-review-approximation.md b/sites/reviews/src/content/research/paper-review-approximation.md
deleted file mode 100644
index 10d7c78..0000000
--- a/sites/reviews/src/content/research/paper-review-approximation.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "Understanding the Latest Approximation Algorithm for Set Cover"
-description: "A detailed walkthrough of a breakthrough approximation algorithm with practical implications."
-pubDate: "Feb 15 2024"
-image: "https://images.unsplash.com/photo-1516321318423-f06f85e504b3?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Understanding the Latest Approximation Algorithm for Set Cover
-
-A recent paper achieves a breakthrough in the Set Cover problem, improving the approximation ratio while maintaining practical runtime.
-
-## The Algorithm
-
-The approach combines local search with a clever LP rounding scheme. The dual interpretation provides beautiful geometric insights.
-
-## Why This Matters
-
-Set Cover appears everywhere - from facility location to machine learning feature selection. This improvement has immediate practical impact.
-
-## Implementation Details
-
-The paper's theoretical elegance translates surprisingly well to practice. Key optimizations include:
-- Lazy evaluation of set intersections
-- Incremental updates to the LP solution
-- Smart caching strategies
-
-## Future Work
-
-The techniques here might extend to weighted variants and online settings.
diff --git a/sites/reviews/src/content/research/paper-review-graph-decomposition.md b/sites/reviews/src/content/research/paper-review-graph-decomposition.md
deleted file mode 100644
index f0e4868..0000000
--- a/sites/reviews/src/content/research/paper-review-graph-decomposition.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "Deep Dive: A New Approach to Graph Decomposition"
-description: "An in-depth analysis of a recent paper on hierarchical graph decomposition and its implications."
-pubDate: "Jan 20 2024"
-image: "https://images.unsplash.com/photo-1507003211169-0a1dd7228f2d?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Deep Dive: A New Approach to Graph Decomposition
-
-This paper introduces a novel framework for decomposing graphs into hierarchical structures that preserve important properties while enabling efficient algorithms.
-
-## The Main Result
-
-The authors prove that every graph with treewidth k can be decomposed into a tree of bags where each bag has size at most k+1. While this sounds like the definition of tree decomposition, the clever twist is in how they construct it.
-
-## Technical Innovation
-
-The key insight is using a charging scheme that amortizes the cost of decomposition across multiple levels. This leads to an O(n log n) algorithm, improving on the previous O(n²) bound.
-
-## Implications
-
-This work opens new avenues for:
-- Parallel algorithms on bounded treewidth graphs
-- Approximation algorithms for NP-hard problems
-- Dynamic programming optimizations
-
-## Open Questions
-
-The paper leaves several intriguing questions open, particularly about the optimality of their charging scheme.
diff --git a/sites/reviews/src/content/research/quantum-algorithms.md b/sites/reviews/src/content/research/quantum-algorithms.md
deleted file mode 100644
index 0eef5b2..0000000
--- a/sites/reviews/src/content/research/quantum-algorithms.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: "Quantum Computing Meets Classical Algorithms"
-description: "Exploring the intersection of quantum and classical algorithmic techniques from recent conferences."
-pubDate: "Mar 10 2024"
-image: "https://images.unsplash.com/photo-1635070041078-e363dbe005cb?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Quantum Computing Meets Classical Algorithms
-
-Recent conferences have showcased fascinating connections between quantum and classical computing paradigms.
-
-## Quantum Speedups for Graph Problems
-
-### Quantum Walks on Graphs
-
-New quantum algorithms achieve quadratic speedups for certain graph traversal problems. The techniques combine amplitude amplification with clever graph representations.
-
-## Classical Simulation of Quantum Algorithms
-
-Surprisingly, several "quantum" algorithms have inspired better classical algorithms. This cross-pollination has led to improvements in both fields.
-
-## The Future is Hybrid
-
-The most practical near-term applications combine quantum and classical processing, leveraging the strengths of each paradigm.
diff --git a/sites/reviews/src/content/reviews/2023-exportober-workflows/alfred-file-search.png b/sites/reviews/src/content/reviews/2023-exportober-workflows/alfred-file-search.png
new file mode 100644
index 0000000..7383195
Binary files /dev/null and b/sites/reviews/src/content/reviews/2023-exportober-workflows/alfred-file-search.png differ
diff --git a/sites/reviews/src/content/reviews/2023-exportober-workflows/blue-square-emoji.png b/sites/reviews/src/content/reviews/2023-exportober-workflows/blue-square-emoji.png
new file mode 100644
index 0000000..bec905b
Binary files /dev/null and b/sites/reviews/src/content/reviews/2023-exportober-workflows/blue-square-emoji.png differ
diff --git a/sites/reviews/src/content/reviews/2023-exportober-workflows/gdoc-autosuggest-links.png b/sites/reviews/src/content/reviews/2023-exportober-workflows/gdoc-autosuggest-links.png
new file mode 100644
index 0000000..b349c06
Binary files /dev/null and b/sites/reviews/src/content/reviews/2023-exportober-workflows/gdoc-autosuggest-links.png differ
diff --git a/sites/reviews/src/content/reviews/2023-exportober-workflows/index.md b/sites/reviews/src/content/reviews/2023-exportober-workflows/index.md
new file mode 100644
index 0000000..6d14a56
--- /dev/null
+++ b/sites/reviews/src/content/reviews/2023-exportober-workflows/index.md
@@ -0,0 +1,109 @@
+---
+title: "Exportober 2023"
+description: "I am going to use this post to document 31 workflows for feeling good about day to day work at the computer, one for each day of October, hopefully! Most of this will be in the..."
+pubDate: "2023-10-01"
+authorName: "Neeldhara"
+sourceCategories: ["workflows"]
+sourcePath: "2023-exportober-workflows/index.qmd"
+---
+
+I am going to use this post to document 31 workflows for feeling good about day to day work at the computer, one for each day of October, hopefully! Most of this will be in the context of macOS, but hopefully the principles are adataptable to the platforms and tools of your choice.
+
+> **Note**
+> 
+> 
+> # (10/01). Faux Hot Key Sequences in Keyboard Maestro
+> 
+> Turns out I am terrible with remembering keyboard shorcuts, so in an ideal world I'd like to have things triggered by single key presses that are awfully predictably related to whatever I want. For example, hit the "b" key to type out a 🟦. Now this is not tenable of course: there are multiple things vying for the "b" trigger, including, well, the letter _b_ wanting to be typed out.
+> 
+> A natural solution is to have a keystroke sequence for disambiguation. So in principle something like "e" followed by "b", where the first "e" signals that they keyboard is to prepare itself for an emoji-based trigger, and the "b" does the blue square thing. However, pure key sequences are also going to get in your way, because most of them will be substrings of naturally typed text.
+> 
+> So you'd want a hot key trigger to say you're going into shortcut mode first: something like `Cmd+K → e → b`. BTT supports such sequences out of the box, but Keyboard Maestro, my default tool for such matters, does not with the following explanation in their [FAQ](https://wiki.keyboardmaestro.com/Frequently_Asked_Questions#How_do_I_use_a_multiple_keystroke_trigger):
+> 
+> > But Keyboard Maestro does not directly support assigning a two-keystroke hot key to a trigger. The problem with multiple keystroke triggers like Option-F R is what to do if you type Option-F A?
+> >
+> > Logic dictates that the Option-F A should go through to the system unimpeded, but Option-F R should be swallowed entirely. But this is impossible. The only way to do it would be to swallow the Option-F key, and then swallow the second key and then resubmit the Option F and the second key unless it matches Option-F R.
+> >
+> > However, that is fraught with peril and cannot work robustly in the presence of other applications placing things on the keyboard event queue (or even a sufficiently fast typist).
+> >
+> > For example, suppose you quickly typed Option-F A B. Keyboard Maestro would have swallowed the Option F and then the A, and then resubmitted it to the event queue, resulting in the stream of characters B, Option-F, A. There is no way to avoid this race condition, and as such Keyboard Maestro does not support any such mechanism.
+> >
+> > As described above, Keyboard Maestro has a variety of ways you can use Option-F as a hot key that allows a second key to be used to select a macro. However in all cases it is clear that the Option-F has been used and there is no concept that the Option-F might come back later to do something else.
+> 
+> However, as a tip from the same FAQ suggests, you can more or less achieve the desired effect by using macro grouping and group activation triggers. So I have a macro group that triggers the square emojis by single keystrokes like so:
+> 
+> ![Keyboard Maestro macro group for emoji triggers](blue-square-emoji.png)
+> 
+> ...but this macro group is only activated for one action at a time, and its activation is triggered by _another KM macro_ - whose only job is to activate this macro group for a single action, like so:
+> 
+> ![Keyboard Maestro macro for activating emoji macro group](trigger-emoji-squares.png)
+> 
+> You might notice that this trigger is also a single keypress (in this example, "U"). This entire macro group is activated for one action with the `Cmd+Alt+K` keystroke. So effectively I only remember the `Cmd+Alt+K` keystroke, which activates this collection of macros for one action:
+> 
+> ![Meta Macros in KM](meta-macro-group.png)
+> 
+> ...and from here I just have to press "U" followed by "B" to get my 🟦. Just this two-level triggering gives access to potentially 500+ triggers that mneomically efficient, and potentially many more actions (for example, you could map "B" to a bunch of different emojis that share blue as the predominant color, and KM will display a pallette for you to do the final disamiguiation).
+> 
+> IRL I use [Rocket](https://matthewpalmer.net/rocket/) by [Matthew Palmer](https://matthewpalmer.net/) to pick out emojis quickly (thanks to a [tip](https://twitter.com/wesbos/status/790607013680074752?lang=mr) from [Wes Bos](https://wesbos.com/)), or just the built-in macOS picker. But I do find the setup described above handy for some unicode symbols that I frequently use.
+> 
+> I should mention [God Mode](https://medium.com/@nikitavoloboev/karabiner-god-mode-7407a5ddc8f6) as another popular way to reduce clutter in the keyboard shortcut mindspace, but I never really got used to Karabiner and am too used to the left CAPS key being mapped to Ctrl for me to give that up to the hyper key.
+
+
+> **Note**
+> 
+> 
+> # (10/02). File Searches with Alfred App
+> 
+> To open a file, I simply open up [Alfred](https://www.alfredapp.com/) and press the spacebar or the `'` symbol and start typing out a filename. This is enabled by going in to Alfred preferences and making sure that `Quick Search: Enable Quick File Search mode` is enabled:
+> 
+> ![Alfred Quick File Search](alfred-file-search.png)
+> 
+> Most launchers have some kind of file search enabled, so look out for it even if you are on, say, [Raycast](https://www.raycast.com/), or [Launchbar](https://www.obdev.at/launchbar), or something else.
+> 
+
+
+> **Note**
+> 
+> 
+> # (10/03). Bookmarks with Static Marks
+> 
+> I use [StaticMarks](https://darekkay.com/static-marks/) to track key locations across the web and my filesystem. Typically, any project that I am working on has some subset of the following key links:
+> 
+> - A Drive/Dropbox or local Folder
+> - A Notes Folder within my PKM system of choice (Obsidian/Quarto)
+> - A Notion or Things page that tracks tasks
+> - A Zoom/Meet URL if meetings/classes are online
+> - Other External URLs (spreadsheets, grading pages, pages on Overleaf/Github, key email threads, and so forth)
+> 
+> I now dump most of this in a YAML file (using [Hookmark](https://hookproductivity.com/) for local folders, so that the links persist even if I move things around) now, and have a few HTML pages that give me a quick overview of all my major projects. I typically restrict myself to the first three or four links, because that covers 90% of what I need quickly, and the other associated external URLs go into the notes page that I have for the project in my whatever-system, so they do end up being at most one hop away from the static marks page.
+> 
+> Previously I used to try to maintain everything within [Arc](https://arc.net/) folders but that got somewhat out of hand, so I swept it all clean and only have more or less top level folders in Arc now representing major themes that I can categorize my efforts into, and each such theme has its own static marks file that I can use to get a nice, searchable big picture.
+> 
+> One thing that I do find annoying in general is the fact that reference material is often common to multiple efforts (e.g, the same papers relevant to multiple research projects). Since I access my files by search, I am perhaps more sensitive than usual to any kind of redundancy --- it clutters up the search results (besides, I prefer a single source of truth on, say PDFs, because I am typically annotating them). These days, I keep my reference material separate from projects, and link them to projects using either a PKM system, or more casually, using Hookmark.
+> 
+> Related: [Bunch](https://bunchapp.co/) by [Brett Terpstra](https://brettterpstra.com/) is a handy plaintext automation tool: the website has some really indicative use cases, go check it out! I don't use this myself but am looking forward to incorporating it into my workflow once my life is sorted enough for me to figure out what I typically do in the context of a specific project, and for said things to be sufficiently distinguishable from complete chaos :)
+> 
+
+
+> **Note**
+> 
+> 
+> # (10/04). Search Links by Brett Terpstra
+> 
+> If you've used `Cmd+K` on Google docs, you may have noticed --- and even been spoiled by --- how Google can figure out your links for you based on the content of the selected text:
+> 
+> ![Google Docs link search](gdoc-autosuggest-links.png)
+> 
+> If you want something similar while editing Markdown files, look no further than the _[Search Links](https://brettterpstra.com/projects/searchlink/)_ service by [Brett Terpstra](https://brettterpstra.com/). It basically has the same effect: my experience is that I select some text and press a shortcut to invoke Search Links, which then does its thing in the background, and then my selected text is replaced by a markdown-formatted link. The results may not be always what you are looking for (I usually try to keep the text descriptive, and potentially edit later if required), but it works most of the time, and saves me the back and forth of having to open a browser, look for the link, copy it over, paste it back and format it in a markdown-appropriate manner. Great for when you don't want to leave your editor!
+> 
+
+
+> **Note**
+> 
+> 
+> # (10/05). Send to Alfred
+> 
+> When something is selected (a bunch of text, or a file or a folder), I can double-tap the `Alt` key to "send" the material to [Alfred](https://www.alfredapp.com/), and to process it further from there. This is very handy: for example, if I want some text switched to title case, it's a few quick keystrokes: double-tap `Alt` on selected text, then `Ctrl+A` to move to the start of text, type out "case", and then `Cmd + 3`: this replaces the selected text with the same text but in title case. This works because I have the [case switch Alfred workflow](https://github.com/gillibrand/alfred-change-case) enabled. I also use this often to open a folder from Finder in VSCode: select folder → send to Alfred → `Open With...` → choose VSCode.
+> 
+> Note: I am yet to find something equivalent to this on Raycast, if anyone has a pointer, please let me know!
+>
diff --git a/sites/reviews/src/content/reviews/2023-exportober-workflows/meta-macro-group.png b/sites/reviews/src/content/reviews/2023-exportober-workflows/meta-macro-group.png
new file mode 100644
index 0000000..7ba07ba
Binary files /dev/null and b/sites/reviews/src/content/reviews/2023-exportober-workflows/meta-macro-group.png differ
diff --git a/sites/reviews/src/content/reviews/2023-exportober-workflows/trigger-emoji-squares.png b/sites/reviews/src/content/reviews/2023-exportober-workflows/trigger-emoji-squares.png
new file mode 100644
index 0000000..ea5f3d2
Binary files /dev/null and b/sites/reviews/src/content/reviews/2023-exportober-workflows/trigger-emoji-squares.png differ
diff --git a/sites/reviews/src/content/reviews/building-websites-with-notion/FireShot_Capture_002_-_Manim_Examples_-_manimexamples.com.png b/sites/reviews/src/content/reviews/building-websites-with-notion/FireShot_Capture_002_-_Manim_Examples_-_manimexamples.com.png
new file mode 100644
index 0000000..c2a7bbe
Binary files /dev/null and b/sites/reviews/src/content/reviews/building-websites-with-notion/FireShot_Capture_002_-_Manim_Examples_-_manimexamples.com.png differ
diff --git a/sites/reviews/src/content/reviews/building-websites-with-notion/ScreenFlow.gif b/sites/reviews/src/content/reviews/building-websites-with-notion/ScreenFlow.gif
new file mode 100644
index 0000000..6523510
Binary files /dev/null and b/sites/reviews/src/content/reviews/building-websites-with-notion/ScreenFlow.gif differ
diff --git a/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_1.00.36_PM.png b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_1.00.36_PM.png
new file mode 100644
index 0000000..cd8b298
Binary files /dev/null and b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_1.00.36_PM.png differ
diff --git a/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_1.29.01_PM.png b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_1.29.01_PM.png
new file mode 100644
index 0000000..ed510b3
Binary files /dev/null and b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_1.29.01_PM.png differ
diff --git a/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_1.30.40_PM.png b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_1.30.40_PM.png
new file mode 100644
index 0000000..2f6f40c
Binary files /dev/null and b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_1.30.40_PM.png differ
diff --git a/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_10.48.49_AM.png b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_10.48.49_AM.png
new file mode 100644
index 0000000..4e83e8f
Binary files /dev/null and b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_10.48.49_AM.png differ
diff --git a/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_10.49.57_AM.png b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_10.49.57_AM.png
new file mode 100644
index 0000000..c6b7516
Binary files /dev/null and b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_10.49.57_AM.png differ
diff --git a/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.00.26_AM.png b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.00.26_AM.png
new file mode 100644
index 0000000..f71c17f
Binary files /dev/null and b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.00.26_AM.png differ
diff --git a/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.00.55_AM.png b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.00.55_AM.png
new file mode 100644
index 0000000..e90eb99
Binary files /dev/null and b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.00.55_AM.png differ
diff --git a/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.03.16_AM.png b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.03.16_AM.png
new file mode 100644
index 0000000..c981a47
Binary files /dev/null and b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.03.16_AM.png differ
diff --git a/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.05.42_AM.png b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.05.42_AM.png
new file mode 100644
index 0000000..01e7bc8
Binary files /dev/null and b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.05.42_AM.png differ
diff --git a/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.06.32_AM.png b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.06.32_AM.png
new file mode 100644
index 0000000..dcf078d
Binary files /dev/null and b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.06.32_AM.png differ
diff --git a/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.06.41_AM.png b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.06.41_AM.png
new file mode 100644
index 0000000..d6656b6
Binary files /dev/null and b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.06.41_AM.png differ
diff --git a/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.08.34_AM.png b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.08.34_AM.png
new file mode 100644
index 0000000..03018b6
Binary files /dev/null and b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.08.34_AM.png differ
diff --git a/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.11.43_AM.png b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.11.43_AM.png
new file mode 100644
index 0000000..040332c
Binary files /dev/null and b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.11.43_AM.png differ
diff --git a/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.18.07_AM.png b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.18.07_AM.png
new file mode 100644
index 0000000..2a45554
Binary files /dev/null and b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.18.07_AM.png differ
diff --git a/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.19.08_AM.png b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.19.08_AM.png
new file mode 100644
index 0000000..a9c5de8
Binary files /dev/null and b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.19.08_AM.png differ
diff --git a/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.22.38_AM.png b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.22.38_AM.png
new file mode 100644
index 0000000..a814925
Binary files /dev/null and b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.22.38_AM.png differ
diff --git a/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.26.06_AM.png b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.26.06_AM.png
new file mode 100644
index 0000000..83ee165
Binary files /dev/null and b/sites/reviews/src/content/reviews/building-websites-with-notion/Screenshot_2021-09-12_at_11.26.06_AM.png differ
diff --git a/sites/reviews/src/content/reviews/building-websites-with-notion/index.md b/sites/reviews/src/content/reviews/building-websites-with-notion/index.md
new file mode 100644
index 0000000..891b854
--- /dev/null
+++ b/sites/reviews/src/content/reviews/building-websites-with-notion/index.md
@@ -0,0 +1,204 @@
+---
+title: "Actually Building a Website with Notion"
+description: "My attempted overview of options for making websites with Notion does not go into the mechanics of how to setup a site with Notion, so I'm going to post a couple of short walkth..."
+pubDate: "2021-09-12"
+authorName: "Neeldhara"
+sourceCategories: ["notion", "workflows", "websites"]
+sourcePath: "building-websites-with-notion/index.qmd"
+---
+
+My attempted [overview of options](https://neeldhara.blog/notion-powered-websites) for making websites with [Notion](https://notion.so) does not go into the mechanics of *how* to setup a site with Notion, so I'm going to post a couple of short walkthroughs of the process here. I'll demonstrate with both [Super](https://super.so) and [Potion](https://potion.so). For Super, I'll share how I setup my course catalog. With Potion, a natural choice would have been to take you behind the scenes of *this* blog, but this did involve a little bit of customization that might be a bit distracting, so I'll just make something quick from scratch for this post.
+
+<blockquote class="twitter-tweet"><p lang="en" dir="ltr">Doesn&#39;t look like it&#39;s for non-geeks like me 😄 or you may prove otherwise. However, if you can record a 10 min video setting up a basic one, that&#39;ll have a greater impact, I believe, if it&#39;s already not there.</p>&mdash; Swaprava Nath (@swaprava) <a href="https://twitter.com/swaprava/status/1436887668143497219?ref_src=twsrc%5Etfw">September 12, 2021</a></blockquote> 
+
+---
+
+### The Overall Process
+
+For either framework, this is typically a three-step process:
+
+1. Setup your content in Notion. You can start from scratch, or use one of the templates provided by Super or Potion that feel like a closest match to what you want your website to eventually look like.
+
+2. Enable sharing to the web from within Notion — this will generate a link for you.
+
+3. Copy this link into Super or Potion.
+
+At the end of step 2, in fact, you already have a URL that you can share with anyone and, depending on how the content is laid out in Notion, can already look like a decent website.
+
+What step 3 allows you to do, however is:
+
+1. Add some styling with CSS.
+
+2. Add custom code snippets (useful, for example, if you want to add things like Google Analytics).
+
+3. Be assured that the webpage is good in terms of SEO, performance, etc.
+
+4. If using Super, you can selectively password-protect pages (coming soon to Potion, where you can presently password-protect your whole site if you want to).
+
+5. Have automatically generated user-friendly URLs for the individual pages, and if on Potion, you get nice preview images for all your pages as well.
+
+A few optional steps that you might want to consider:
+
+1. By default, both Super and Potion will give you a test subdomain to work with. Eventually, you might want the website to be available from your own domain. This is just a matter of adding a couple of A-records and typically can be done from wherever you registered the domain:
+
+![](Screenshot_2021-09-12_at_10.49.57_AM.png)
+
+![](Screenshot_2021-09-12_at_10.48.49_AM.png)
+
+2. You might want to add custom styles to make the website render uniquely — so you move beyond the standard look-and-feel of a Notion page if you so wish. You could do something on your own here, but the simplest thing is to just borrow the styling from one of the existing templates and tweak it if you want.
+3. Insert code for Google Analytics (or similar). As an aside, if you are looking for analytics that is user-friendly *and* privacy-conscious, I'd recommend [Fathom](https://usefathom.com).
+
+### A Course Catalog with Super
+
+> **Warning**
+> 
+> ## Heads up!
+> 
+> This content is deprecated because I've moved this domain out to a different setup now. So please ignore the links, and hopefully the steps are still useful in principle!
+
+
+Let's apply this process to an actual website now! I'll demonstrate how I setup the website at [`neeldhara.courses`](https://neeldhara.courses). Incidentally, if you want a quick overview without some details that will be specific to my website, you might want to watch the video made by @robhope and pointed out by @traf.
+
+<blockquote class="twitter-tweet"><p lang="en" dir="ltr">Here&#39;s a little run through by <a href="https://twitter.com/robhope?ref_src=twsrc%5Etfw">@robhope</a> on creating a site <a href="https://twitter.com/super_?ref_src=twsrc%5Etfw">@super_</a>:<a href="https://t.co/SCMdDMRfBd">https://t.co/SCMdDMRfBd</a></p>&mdash; traf (@traf) <a href="https://twitter.com/traf/status/1436888874165411847?ref_src=twsrc%5Etfw">September 12, 2021</a></blockquote> 
+
+
+Back to the setup for [`neeldhara.courses`](http://neeldhara.courses). You can check out the page on Notion [here](https://www.notion.so/Courses-722e231ca8e549159af5a8e7700a5025), but I'll describe some pieces of it below. First, recall Step 1:
+
+<aside>
+1️⃣ *Setup your content in Notion.*
+
+</aside>
+
+I started with the [Super template HQ](https://hq.super.site). It looks amazing and is apparently free to use — at least at the time of this writing 😀
+
+Duplicate this template into Notion. If you like, you can duplicate it twice — one, a copy that you actually work on, and the other could be a copy that you don't edit but just keep handy in case you need to go back to the original for reference.
+
+The first thing I did was to get rid of most of the content, and just retained this section:
+
+![](Screenshot_2021-09-12_at_11.00.55_AM.png)
+
+which, incidentally, will render like this once connected to Super:
+
+![](Screenshot_2021-09-12_at_11.00.26_AM.png)
+
+Now the next step is to replace the generic content with yours:
+
+![](Screenshot_2021-09-12_at_11.03.16_AM.png)
+
+Since I'm just starting out, I have added the three courses that I'm teaching this term and they all show up. Eventually, these courses will be filtered out based on the current timing, so that only the current ones show here and the rest get pushed to an archive — which I'm yet to build. But the filter would look something like this in Notion:
+
+![](Screenshot_2021-09-12_at_11.05.42_AM.png)
+
+And for each of those entries, I'd go and setup the course home pages with the content that I have in my typical course homepages. The nice thing about Notion is the wide array of content types that lets you format things nicely. Here are a couple of sections from within Notion:
+
+![](Screenshot_2021-09-12_at_11.06.32_AM.png)
+
+![](Screenshot_2021-09-12_at_1.29.01_PM.png)
+
+One thing worth pointing out for this particular setup — for each course, the class plan is just a Notion database, where the columns are:
+
+1. Name (text)
+2. Week (single-select with 12 options; one for each week of the course)
+3. Module (a checkbox property)
+4. Description (text)
+
+and the rows either correspond to an overview of a whole week or just one individual lecture, tagged with the week that it happened in.
+
+On the course's homepage, I display this database set to a Gallery view, and filtered to only those entries where the Module option is *unchecked*. These are intended to be overview pages. This is what it looks like in Notion:
+
+![](Screenshot_2021-09-12_at_11.06.41_AM.png)
+
+and this is what it will end up looking like on the website, once you've gotten to the end of Step 3:
+
+![](Screenshot_2021-09-12_at_11.18.07_AM.png)
+
+Further, overview page simply displays the same database again, this time in a list view filtered by the appropriate week:
+
+![](Screenshot_2021-09-12_at_11.11.43_AM.png)
+
+Check out the views in Notion and the rendered version side-by-side:
+
+![](Screenshot_2021-09-12_at_11.08.34_AM.png)
+![](Screenshot_2021-09-12_at_11.19.08_AM.png)
+You might wonder about the blockquote in the Notion view right at the top of the page. That's a feature of the HQ template — anything that goes into that first blockquote renders as page navigation on top. I think this now a bit obsolete with Super's new features on navigation bars, but I still find it handy and use it on most pages. 👍
+
+So that's all of Step 1, getting all your content inside Notion. I'd say this is really the bulk of the process. The process is iterative, so you don't need literally *all* your content in before you can move on. However, getting an indicative amount thrown in is, I think, useful.
+
+Once you're done with this bit, up next:
+
+<aside>
+2️⃣ Enable sharing to the web from within Notion — this will generate a link for you.
+
+</aside>
+
+This is very easy to do, it's just a toggle on the top-right corner of your Notion app:
+
+![](Screenshot_2021-09-12_at_11.22.38_AM.png)
+
+Now for the final step to have everything come together:
+
+<aside>
+3️⃣ Copy this link into Super or Potion.
+
+</aside>
+
+This is again quite straightforward, head to Super and just share your page's public URL, give it a name, and optionally set it up to sync with your domain if you have one.
+
+![](Screenshot_2021-09-12_at_11.26.06_AM.png)
+
+Given that we're using a particular Super template, you would also need to remember to insert the CSS to make the site look as advertised above 😅
+
+So remember to add this on the custom code section of your Super dashboard:
+
+`<link rel="stylesheet" href="[https://sites.super.so/hq/style.css](https://sites.super.so/hq/style.css)">`
+
+If you do just this and are literally following along your site may still look a little different from mine, which is probably because I tweaked the CSS a bit to incorporate fonts of my liking (the fonts in the screenshot are from Google fonts — [Andika New Basic](https://fonts.google.com/specimen/Andika+New+Basic) and [Shadows into Light Two](https://fonts.google.com/specimen/Shadows+Into+Light+Two)).
+
+You might want to take care of some minor things at this stage, such as adding a favicon, a site description that will show up on Google searches, inserting any code you need to for analytics, and so forth.
+
+The very first time that you setup your site, you may need to wait for a bit for it to build and render. But after this first time, any edits you make on Notion are reflected automatically on your website — you may need to give it a minute or two, it's not instantaneous, but trust that the changes will show up. Clear your cache if they don't even after a couple of minutes.
+
+Super generates pretty URLs automatically for all your pages, but because of the slightly peculiar setup I have, involving a particular nested structure and filtered views, I've been doing my pretty URLs manually. For example, to go to the second module of Week 5 in the competitive programming course, the URL is:
+
+```python
+https://neeldhara.courses/competitive-programming/week-05/mod-02
+```
+
+This can be setup quite easily from inside the Super dashboard, and once it's done once, it's done for good.
+
+So, that's about it! I'd like to think I covered most major aspects, but if anything is unclear, ping me @neeldhara on Twitter and I'll be sure to update this appropriately 🙂
+
+### The Manim Examples Collection with Potion
+
+For the Potion example, I'd like to build out a quick page with latest tweets from @manim_community. Manim is a community-maintained Python library for creating mathematical animations, and the twitter handle pulls in a lot of great examples.
+
+> **Note**
+> 
+> ## Incidentally, if you prefer watching a video tutorial, Potion has you covered already...
+> 
+> <iframe width="560" height="315" src="https://www.youtube.com/embed/qhqEqh9shik" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
+
+
+So, for step 1, which is to get our content in Notion, I start with a blank slate and populate it with some content:
+
+![](Screenshot_2021-09-12_at_1.00.36_PM.png)
+
+![](Screenshot_2021-09-12_at_1.30.40_PM.png)
+
+For Step 2, I simply make this page public, and you can see the [Notion version here](https://www.notion.so/Manim-Examples-4e4dd0c1071e4a549d90be74a84f3cce).
+
+For Step 3, I add this page to Potion and just follow [step 4 on this page](https://www.potion.so/cards-portfolio) to set this up with a lovely template made by Dr. Gil Pradana (@[gildy](https://twitter.com/gildy)). This just amounts to copy-pasting some CSS code into the *Snippet Injection* section of your Potion dashboard. This template treats horizontal line breaks as breakpoints to create cards, and the headings translate into the highlight boxes that you can see from this preview.
+
+[https://twitter.com/gildy/status/1403680404092035075?s=20](https://twitter.com/gildy/status/1403680404092035075?s=20)
+
+After connecting my domain, here's what the website looks like this![](FireShot_Capture_002_-_Manim_Examples_-_manimexamples.com.png)
+
+And that's basically it! You have a fully functional page now. 🎉  Changes you make in Notion will reflect *instantaneously* on Potion!
+
+![](ScreenFlow.gif)
+
+You might wonder if there is a way of setting things up so that new tweets from the Manim community handle show up automatically on this website. In principle, this should be possible with a little help from tools like automate.io, Zapier, or Integromat — they can watch for new tweets and append them to the page you are working on, although I'm not sure how to set it up so that they respect the two-column layout that I have here. I figure tweets could also be added to a database and shown with a gallery view instead, but the gallery previews will typically not pick up embedded content, so you might have to go via an intermediate service like [Tweetpik](https://tweetpik.com/) or [Pikaso](https://pikaso.me/) instead so you have screenshots for display.
+
+So this was Potion - you can probably see the many ways in which Potion and Super are similar to setup. By the way, the templates on these platforms are *not* mutually compatible — so watch out for the fact that they will not automatically work on the other platform if you are looking to migrate. As far as I can see, neither service has an importer for the other built yet.
+
+That said, I hope you have fun making your website with Notion with whatever platform you choose to use! 🎉
diff --git a/sites/reviews/src/content/reviews/django-app/Untitled.png b/sites/reviews/src/content/reviews/django-app/Untitled.png
new file mode 100644
index 0000000..67b3737
Binary files /dev/null and b/sites/reviews/src/content/reviews/django-app/Untitled.png differ
diff --git a/sites/reviews/src/content/reviews/django-app/Untitled1.png b/sites/reviews/src/content/reviews/django-app/Untitled1.png
new file mode 100644
index 0000000..460ad55
Binary files /dev/null and b/sites/reviews/src/content/reviews/django-app/Untitled1.png differ
diff --git a/sites/reviews/src/content/reviews/django-app/Untitled2.png b/sites/reviews/src/content/reviews/django-app/Untitled2.png
new file mode 100644
index 0000000..5a3a3d5
Binary files /dev/null and b/sites/reviews/src/content/reviews/django-app/Untitled2.png differ
diff --git a/sites/reviews/src/content/reviews/django-app/Untitled3.png b/sites/reviews/src/content/reviews/django-app/Untitled3.png
new file mode 100644
index 0000000..e17b31c
Binary files /dev/null and b/sites/reviews/src/content/reviews/django-app/Untitled3.png differ
diff --git a/sites/reviews/src/content/reviews/django-app/Untitled4.png b/sites/reviews/src/content/reviews/django-app/Untitled4.png
new file mode 100644
index 0000000..9481306
Binary files /dev/null and b/sites/reviews/src/content/reviews/django-app/Untitled4.png differ
diff --git a/sites/reviews/src/content/reviews/django-app/Untitled5.png b/sites/reviews/src/content/reviews/django-app/Untitled5.png
new file mode 100644
index 0000000..27ef2d9
Binary files /dev/null and b/sites/reviews/src/content/reviews/django-app/Untitled5.png differ
diff --git a/sites/reviews/src/content/reviews/django-app/hellodjango-screenshot-08.png b/sites/reviews/src/content/reviews/django-app/hellodjango-screenshot-08.png
new file mode 100644
index 0000000..2c30d34
Binary files /dev/null and b/sites/reviews/src/content/reviews/django-app/hellodjango-screenshot-08.png differ
diff --git a/sites/reviews/src/content/reviews/django-app/index.md b/sites/reviews/src/content/reviews/django-app/index.md
new file mode 100644
index 0000000..bfc4a92
--- /dev/null
+++ b/sites/reviews/src/content/reviews/django-app/index.md
@@ -0,0 +1,390 @@
+---
+title: "Building a first Django App"
+description: "In preparing for a session in a Python workshop (organised for teachers of the CBSE board who are teaching students informatics and computer science in 11th/12th grades, and who..."
+pubDate: "2018-06-12"
+authorName: "Neeldhara"
+sourceCategories: ["tutorial", "websites"]
+sourcePath: "django-app/index.qmd"
+---
+
+In preparing for a session in a Python workshop (organised for teachers of the CBSE board who are teaching students informatics and computer science in 11th/12th grades, and who have recently had their official syllabus switch from C++ to Python), I finally got around to exploring the process of building a webapp powered by Django. I picked up the excellent [Hello Web App](https://hellowebbooks.com/learn-django/) book by [Tracy Osborn](https://limedaring.com/) for my preparation. In this post, I am going to document the process — just in case I have to do this again ☕️
+
+The tutorial in Hello Web App goes over the process of building a generic “collection of things” with Django. In this tutorial, I’ll focus on a more concrete example, because it was more fun for me to build a tangible concept that I might actually use later.
+
+So, I am going to build a collection of talk announcements at IIT Gandhinagar, which I intend to be displayed, on the frontend, as a slideshow. I figure that this website can then be loaded up on any internet-connected display and serve as a virtual notice board. For the frontend design, I’m going to be stealing the Webslides framework, which is a really clean HTML/CSS template for making slideshows powered by Javascript.
+
+### Quickstart
+
+I’m going to handwave the bit about installation. Briefly, I setup Django v2.0.4 in a virtual environment, put the codebase in a git repository, and initialized a Django project via:
+
+`django-admin startproject announceiitgn .`
+
+and then a Django app via:
+
+`django-admin startapp talks`
+
+It’s also important to add this app to `settings.py`, like so:
+
+```jsx
+INSTALLED_APPS = [
+'talks',
+'django.contrib.admin',
+'django.contrib.auth',
+'django.contrib.contenttypes',
+'django.contrib.sessions',
+'django.contrib.messages',
+'django.contrib.staticfiles',
+]
+```
+
+and also run a migration command to account for an initial setup for the databases (if you skip this step, Django will prompt you to do it anyway — as I found out by forgetting 😎):
+
+`python [manage.py](http://manage.py/) migrate`
+
+Finally, see your app by running the server! 🎉
+
+`python [manage.py](http://manage.py/) runserver`
+
+You should see a neat little success page if you navigate to something like [http://127.0.0.1:8000/](http://127.0.0.1:8000/) (the exact URL should be in your console).
+
+If you are not sure how to get to this point, I’d suggest looking up an installation/setup guide such as this one from the official documentation or this one from Django Girls.
+
+### Setting up Templates
+
+The first step is to setup a basic HTML template that becomes the frontend. We go into our app directory (which, in my case, is `talks`) and then make a templates directory inside it, where I make a simple `index.html` file. Instead of using a skeleton file here, I’m going to take a deep breath and throw in the index.html from the webslides codebase. At this point I know it won’t be a pretty sight, but I’m also optimistic that I can iron it out as I go along 🤕
+
+I’m going to head over to `urls.py` and add the following import:
+
+`from talks import views`
+
+and then add the following item to urlpatterns, which I understand only vaguely at this point:
+
+`path('',views.index,name='home'),`
+
+We now need to make sure that views.index actually makes sense, so switch to [views.py](http://views.py/) in the talks directory and add the following:
+
+```jsx
+def index(request):
+return render(request,'index.html')
+```
+
+Note that `render` has already been imported for you from `django.shortcuts`. For now, I sense that this is the plumbing connecting the directive in `urls.py` to the meat in the templates directory. Now, navigating again to the webapp, while it’s not exactly pretty (just as predicted), but at least you can see that all the connections are working as intended:
+
+> **Caution**
+> 
+> ## Click toggle to reveal a full-page screenshot of an unstyled webpage!
+> 
+> ![](Untitled.png)
+
+
+So it’s time to add the static supporting files for the webslides template. I’m going to create the folder `static` inside the `talks` folder. Inside the static folder, copy over the folders `css`, `js` and `images` from the webslides template bundle. Now, we need to make sure that our `index.html` loads these supporting files from the appropriate location. This is a critical step and will completely transform the way the website is rendered if done correctly. So what we are going to do is add the following line to the top of the file:
+
+`{% load staticfiles %}`
+
+Next, find all instances of anything that looks like:
+
+`<link rel="stylesheet" type='text/css' media='all' href="static/css/webslides.css">`
+
+and change it to:
+
+`<link rel="stylesheet" type='text/css' media='all' href="{% static 'css/webslides.css' %}">`
+
+Careful with getting the quotes and the template tags in place accurately! Also remember to attack every instance of a reference to anything the static/ directory. If you are comfortable with it, this is a near-one-shot find and replace with a regex search.`
+
+You could also make this work by using relative paths (i.e., changing the paths to `../css/webslides.css`), but using the Django template tags as above is more robust to changes in the directory structure — so in case your static files folder moves around, your code doesn’t have to change.
+
+Now, for the moment of truth, restart the server:
+
+`python [manage.py](http://manage.py/) runserver`
+
+and revisit your site:
+
+![](Untitled1.png)
+
+So there! We’ve managed to render the webslides deck inside of our Django project — which is an awesome start already: 🎉
+
+### Starting Clean
+
+Of course, we don’t quite want the `index.html` file to hold this particular content. I’m going to quickly pick out a slide (from the webslides demonstrations) that looks nice for displaying talk announcements, and get rid of all the original sections and just use this one. Here’s the HTML for the sections that I ended up with, populated with some sample content:
+
+```jsx
+<section>
+<div class="wrap">
+<div class="card-30 bg-white">
+<div class="flex-content">
+<h2>Talk Title 1
+</h2>
+<p>Speaker Name & Affiliation</p>
+<p class="text-intro">A brief abstract of the talk.
+</p>
+<ul class="description">
+<li><strong class="text-label">Date:</strong> 16 June 2018</li>
+<li>
+<strong class="text-label">Time:</strong> 10:00 AM
+</li>
+<li><strong class="text-label">Venue:</strong> Academic Block 1, Room 101</li>
+</ul>
+</div>
+<!-- end .flex-content-->
+</div>
+<!-- .end .card-50 -->
+</div>
+<!-- .end .wrap -->
+</section>
+
+```
+
+Of course, this data would eventually be passed into the template from the database, but let’s render our site anyway and check it out once more before moving on:
+
+![](Untitled2.png)
+
+It’s not hard to customize the header from index.html, but I am postponing that for a little bit later.
+
+### Template Inheritance
+
+It’s useful to have global-ish aspects of our template separated out into a (presumably traditionally named) base.html template, so we can make spin-offs easily. For example, when we have interviews we like to display room numbers for candidates interviewing for different disciplines on the same day, and some related general information. This page will carry the same overall structure, but we might want to use a slightly different combination of section templates. So let’s rip out the generic stuff from index.html and move it to base.html:
+
+```html
+{% load staticfiles %}
+...bunch of webslides header stuff...
+
+<main role="main">
+  <article id="webslides" class="vertical">
+
+    {% block content %}
+    {% endblock content %}
+
+  </article>
+  <!-- end article -->
+</main>
+<!-- end main -->
+...bunch of webslides footer stuff...
+```
+
+(Please don’t copy-paste this, work with your own webslides template if you are literally following along! I’ve not dislpayed a bunch of stuff from their index.html in the interest of space.)
+
+Meanwhile, your `index.html` now looks like this:
+
+```html
+{% extends 'base.html' %}
+{% load staticfiles %}
+{% block content %}
+<section>
+<div class="wrap">
+<div class="card-30 bg-white">
+<div class="flex-content">
+<h2>Talk Title 1
+</h2>
+<p>Speaker Name & Affiliation</p>
+<p class="text-intro">A brief abstract of the talk.
+</p>
+<ul class="description">
+<li><strong class="text-label">Date:</strong> 16 June 2018</li>
+<li>
+<strong class="text-label">Time:</strong> 10:00 AM
+</li>
+<li><strong class="text-label">Venue:</strong> Academic Block 1, Room 101</li>
+</ul>
+</div>
+<!-- end .flex-content-->
+</div>
+<!-- .end .card-50 -->
+</div>
+<!-- .end .wrap -->
+</section>
+{% endblock content %}
+
+```
+
+Remember to make sure that the line:
+
+`{% extends 'base.html' %}`
+
+is the very first thing in your file, and that you add:
+
+`{% load staticfiles %}`
+
+in case you plan to use anything in your static directory in index.html. The power of inheritance becomes a little more evident when you have other files piggybacking on base.html, but I’ll leave that to your imagination for now.
+
+### Setting up the Database
+
+We’re going to start by creating an admin user, by typing the following into the commandline:
+
+`python manage.py createsuperuser`
+
+This prompts for a username, email and password — nothing out of the ordinary here. Next up is a critical point in this whole exercise, which is to setup the model, or the database schema, for the items we wanted to display. From the HTML above you might have guessed that what I want to define at this point is a talk object with the following attributes:
+
+1. Talk Title
+2. Speaker Name
+3. Venue
+4. Date
+5. Time
+
+To capture this, add the code below to models.py:
+
+```python
+class Talk(models.Model):
+	title = models.CharField(max_length=255)
+	speaker = models.CharField(max_length=255)
+	description = models.TextField()
+	venue = models.CharField(max_length=255)
+	date = models.DateField()
+	time = models.TimeField()
+```
+
+The field types should be self-explanatory. One type that I did not use was the SlugField, which can be handy if you want every talk to have its own page. For now, we’re keeping it simple. We then ask Django to pick up this updated database plan by running migrations as follows:
+
+`python manage.py makemigrations`
+`python manage.py migrate`
+
+We next get the built-in Django admin interface up to speed with information about our new database, by adding the following lines to `admin.py` in the `Talks` folder:
+
+```python
+from talks.models import Talk
+class TalkAdmin(admin.modelAdmin):
+model = Thing
+list_display = ('title','speaker','description','venue','date','time')
+admin.site.register(Talk, TalkAdmin)
+```
+
+The business with the `TalkAdmin` class is optional, but it lets you do nice things like prepopulate fields where relevant: for instance, if we had a slug field, we could have said something like:
+
+`prepopulated_fields = {'slug'}: ('name',)}`
+
+just after the list_display line above, and you could see the slug getting automatically generated in the admin interface. Speaking of admin interfaces, let’s check ours out — head over to [http://127.0.0.1:8000/admin/](http://127.0.0.1:8000/admin/) and login with your superuser credentials. Here’s what I see:
+
+![](Untitled3.png)
+
+You should find your own data in the users table. But the interesting bits are in the Talks table, which is going to look exactly the way we modeled it above when you go to the table and click on the Add Talk button:
+
+![](Untitled4.png)
+
+Now let’s go ahead and add some sample data in here:
+
+![](Untitled5.png)
+
+I added this from the admin interface. If you like, you can setup forms for other users to add data to the database, but that’s going to be beyond the scope of our first app. For now, let’s get to tying this all together by getting the data from here to display on the frontend…
+
+### Displaying Dynamic Content
+
+If you’ve come this far, you are now ready to pull your data into the slideshow that we setup from before. First, let’s get into `views.py`, pull the data from our database, and pass it on to our template. Modify the file so it looks like this:
+
+```python
+from django.shortcuts import render
+from talks.models import Talk
+
+#Create your views here.
+
+def index(request):
+talks = Talk.objects.all()
+return render(request, 'index.html', {
+'talks': talks,
+})
+```
+
+Next, let’s head back to our index.html file, and adapt our content block:
+
+```html
+{% extends 'base.html' %}
+{% load staticfiles %}
+{% block content %}
+{% for talk in talks %}
+<section>
+<div class="wrap">
+<div class="card-30 bg-white">
+<div class="flex-content">
+<h2>{{ talk.title }}
+</h2>
+<p>{{ talk.speaker }}</p>
+<p class="text-intro">{{ talk.description }}
+</p>
+<ul class="description">
+<li><strong class="text-label">Date:</strong> {{ talk.date }}</li>
+<li>
+<strong class="text-label">Time:</strong> {{ talk.time }}
+</li>
+<li><strong class="text-label">Venue:</strong> {{ talk.venue }}</li>
+</ul>
+</div>
+	<!-- end .flex-content-->
+</div>
+<!-- .end .card-50 -->
+</div>
+<!-- .end .wrap -->
+</section>
+{% endfor %}
+{% endblock content %}
+
+```
+
+Note that we’re now using a for loop to go over everything in talks, and replacing our static content with template tags that represent the corresponding data from the database. Django has a lot of interesting ways in which you can format your content (such as dates and times, especially, but even text strings — for instance, they can always be rendered in title case, if you like, and so on). Since the default view here is not bad, I won’t be pursuing this further — but it’s good to know that you can do [cool things](https://docs.djangoproject.com/en/dev/ref/contrib/humanize/).
+
+Let’s check out our site now, to relish the sight of the slides populated with conent from our database:
+
+![](https://f.v1.n0.cdn.getcloudapp.com/items/3x0b3B0Q363a2l1t3v0c/Screen%20Recording%202018-06-16%20at%2011.01%20AM.gif)
+
+### Filtering Dynamic Content
+
+Let’s say we only want to display those talks whose date is not in the past — this is a natural ask, we don’t want our virtual notice board to be cluttered with information about talks from the past (that’s more suitable for a talk archive page), and we also don’t want to have to delete talks from the database manually (two issues with this: the first is that manual is tedious, the second is that it’s nice to keep the data — quite likely the developer of the future archive page will find it useful).
+
+One way to do this is to loop through all the talks in our template file, and setup a conditional for whether we display it. The main problem doing it this way is that we are doing waaaay more work than is called for: eventually this database will have thousands of talks, while you probably need to get hold of a dozen or so of them. The more appropriate solution is to setup what is called a filter when you make the database query. After some fiddling around, I finally got to this updated query in my views file:
+
+`talks = Talk.objects.filter(date__gte=datetime.now()).order_by('date')`
+
+Remember to import datetime for the above to work:
+
+`from datetime import datetime`
+
+The syntax here is almost self-explanatory: we got rid of the `.all()` and replaced it with a `.filter()` to indicate that, indeed, we don’t want all records but only those that match the filter criteria. Next, `gte` stands for greater than or equal to; `datetime.now()` refers to today’s date; while the `order_by` directive asks the retrieved objects to be ordered according to a particular field. You can order by this-then-that by simply adding multiple fields separated by commas, and you can reverse the order by adding a leading hyphen (or a “minus”, if you like) to the field name. Try all this out! Also: try to mess around with the query to see what happens when the query returns an empty set of records.
+
+Going back to our app, we see that the one talk that was in the past (at the time of this writing) is now gone:
+
+![](https://f.v1.n0.cdn.getcloudapp.com/items/143Y3I033C0c18112o15/Screen%20Recording%202018-06-16%20at%2001.34%20PM.gif)
+
+### Finishing Touches
+
+One thing I didn’t touch upon was how to pass Python variables into the template. Let’s try this now, by adding a final slide that displays today’s date and a nice background image (which resides in the `images/` folder under the `static` directory). To pull out today’s date, let’s set a variable `currdate` in our views file, and pass it on to our template, like so:
+
+```python
+def index(request):
+	talks = Talk.objects.filter(date__gte=datetime.now()).order_by('date')
+	currdate = datetime.now()
+	return render(request, 'index.html', {
+		'talks': talks,
+		'currdate': currdate,
+})
+```
+
+Back to the template, as before, I picked up a nice-looking section from the vast array of webslide’s demo pages. Carefully add this section after the forloop block ends:
+
+```html
+<section class="bg-gradient-v slide-bottom">
+<span class="background light" style="background-image:url('{% static 'images/campus-bg.png' %}')"></span>
+	<div class="wrap">
+		<div class="content-right">
+			<h3 class="alignright">{{ currdate|date }}</h3>
+		</div>
+	</div>
+<!-- .end .wrap -->
+</section>
+```
+
+Note the use of `{{ currdate|date }}` — this displays the value of the variable `currdate` but formatted so that only the date is displayed (without the trailing date instruction, this would display the date and the time by default). This gives us a cool final slide:
+
+![](https://f.v1.n0.cdn.getcloudapp.com/items/1B1y3x1r3j3l0l0B1c2G/Screen%20Recording%202018-06-16%20at%2001.42%20PM.gif)
+
+Also remember to head back to `base.html` and customize the header so the social media links and the logos are relevant to your setting:
+
+![](hellodjango-screenshot-08.png)
+
+### Beyond the First App
+
+Our app was, by design, a largely view-only app. In most situations, however, your app will likely have users, so you would want features like:
+
+- Registration (possibly even single-sign ons)
+- A Login Flow (optionally, also an onboarding flow)
+- Reset Password
+- The ability for users to view user-specific data
+- The ability for users to add/edit/delete user-specific data
+
+For a lot of this you would need to invoke some kind of a customized form interface (different from Django’s built-in admin interface) that allows the user to interact with the database. Covering this is beyond the scope of our discussion, but if you would like to set these things up, I’d suggest continuing your journey with either [this Django tutorial series](https://simpleisbetterthancomplex.com/series/2017/09/04/a-complete-beginners-guide-to-django-part-1.html), [the official documentation](https://docs.djangoproject.com/en/2.0/), or [Hello Web App](https://hellowebbooks.com/learn-django/). Have fun!
diff --git a/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_3.29.11_PM.png b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_3.29.11_PM.png
new file mode 100644
index 0000000..4098bda
Binary files /dev/null and b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_3.29.11_PM.png differ
diff --git a/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_3.33.56_PM.png b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_3.33.56_PM.png
new file mode 100644
index 0000000..f543726
Binary files /dev/null and b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_3.33.56_PM.png differ
diff --git a/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_3.43.12_PM.png b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_3.43.12_PM.png
new file mode 100644
index 0000000..8ad742a
Binary files /dev/null and b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_3.43.12_PM.png differ
diff --git a/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_4.35.18_PM.png b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_4.35.18_PM.png
new file mode 100644
index 0000000..7157749
Binary files /dev/null and b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_4.35.18_PM.png differ
diff --git a/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_4.37.52_PM.png b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_4.37.52_PM.png
new file mode 100644
index 0000000..4a8109b
Binary files /dev/null and b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_4.37.52_PM.png differ
diff --git a/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_4.56.45_PM.png b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_4.56.45_PM.png
new file mode 100644
index 0000000..7f2d751
Binary files /dev/null and b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_4.56.45_PM.png differ
diff --git a/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_5.50.57_PM.png b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_5.50.57_PM.png
new file mode 100644
index 0000000..1d08c9f
Binary files /dev/null and b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_5.50.57_PM.png differ
diff --git a/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_6.30.27_PM.png b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_6.30.27_PM.png
new file mode 100644
index 0000000..cd29af0
Binary files /dev/null and b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_6.30.27_PM.png differ
diff --git a/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_6.38.19_PM.png b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_6.38.19_PM.png
new file mode 100644
index 0000000..bbc3222
Binary files /dev/null and b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_6.38.19_PM.png differ
diff --git a/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_6.42.06_PM.png b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_6.42.06_PM.png
new file mode 100644
index 0000000..20726d7
Binary files /dev/null and b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_6.42.06_PM.png differ
diff --git a/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_7.57.35_PM.png b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_7.57.35_PM.png
new file mode 100644
index 0000000..cceff35
Binary files /dev/null and b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_7.57.35_PM.png differ
diff --git a/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_8.18.35_PM.png b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_8.18.35_PM.png
new file mode 100644
index 0000000..745c830
Binary files /dev/null and b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_8.18.35_PM.png differ
diff --git a/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_8.23.47_PM.png b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_8.23.47_PM.png
new file mode 100644
index 0000000..7d198ae
Binary files /dev/null and b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_8.23.47_PM.png differ
diff --git a/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_8.37.56_PM.png b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_8.37.56_PM.png
new file mode 100644
index 0000000..ffc125a
Binary files /dev/null and b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_8.37.56_PM.png differ
diff --git a/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_8.47.47_PM.png b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_8.47.47_PM.png
new file mode 100644
index 0000000..91782fe
Binary files /dev/null and b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_8.47.47_PM.png differ
diff --git a/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_9.08.56_PM.png b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_9.08.56_PM.png
new file mode 100644
index 0000000..3a9506d
Binary files /dev/null and b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_9.08.56_PM.png differ
diff --git a/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_9.11.50_PM.png b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_9.11.50_PM.png
new file mode 100644
index 0000000..d1e9b32
Binary files /dev/null and b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_9.11.50_PM.png differ
diff --git a/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_9.49.12_PM.png b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_9.49.12_PM.png
new file mode 100644
index 0000000..0847eee
Binary files /dev/null and b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_9.49.12_PM.png differ
diff --git a/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_9.57.40_PM.png b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_9.57.40_PM.png
new file mode 100644
index 0000000..d5aef66
Binary files /dev/null and b/sites/reviews/src/content/reviews/envelope-budgeting-notion/Screenshot_2021-09-18_at_9.57.40_PM.png differ
diff --git a/sites/reviews/src/content/reviews/envelope-budgeting-notion/index.md b/sites/reviews/src/content/reviews/envelope-budgeting-notion/index.md
new file mode 100644
index 0000000..e9c226f
--- /dev/null
+++ b/sites/reviews/src/content/reviews/envelope-budgeting-notion/index.md
@@ -0,0 +1,220 @@
+---
+title: "Envelope Budgeting with Notion"
+description: "YNAB (c.f. r/YNAB) (short for You Need a Budget ) is a budgeting application that lets you track and manage your finances. Like most apps in this category, it provides a slick i..."
+pubDate: "2021-09-18"
+authorName: "Neeldhara"
+sourceCategories: ["notion", "workflows", "tutorial"]
+sourcePath: "envelope-budgeting-notion/index.qmd"
+---
+
+[YNAB](https://www.youneedabudget.com) (c.f. [r/YNAB](https://www.reddit.com/r/ynab)) (short for *You Need a Budget*) is a budgeting application that lets you track and manage your finances. Like most apps in this category, it provides a slick interface to enter all your transactions. YNAB is more than just cataloging transactions and tracking account balances, though. The design here revolves around (and goes beyond) what is called [envelope budgeting](https://en.wikipedia.org/wiki/Envelope_system), which basically boils down to this:
+
+> Give every dollar a job.
+
+You can dig a little deeper into how YNAB works by looking up their [four rules](https://www.youneedabudget.com/the-four-rules/) here. I am going to try and create an envelope budgeting system in Notion that is loosely inspired by my use of YNAB.
+
+To be clear, I don't expect to stop using YNAB, nor do I expect to replicate many of its sophisticated features. Also, there are some nice envelope budgeting systems on Notion already! For instance, you might want to check out the one [here](https://www.reddit.com/r/Notion/comments/mzfog5/envelope_budget_zerobased_budget_system/) by [u/sff_fan_17](https://www.reddit.com/user/sff_fan_17/) or [the one here](https://www.notion.so/Zero-based-Budget-21f015953116430ba4c3414a4691081e) by [Ben Smith](https://t.co/3Vv2zRGQuy?amp=1). These are really neat, but the only reason I'm not just duplicating one of them is that what I have in mind looks slightly different from the setups here. In particular, I would like the transactions to be dated and tied to specific accounts, and I would also like the system here to account for *all* the inflows and outflows in my actual system. Neither of these templates feature a hierarchy of categories either, which is something that we will attempt to do here.
+
+In the first template above, I think the total income is mentioned separately, outside of the database system; and the budget covers a part of the total available income. There are explicit instructions on how to update this month-to-month, so do check this out — perhaps it works for what you might have in mind! The second template explicitly accounts for inflows, and is apparently based on [this Google sheet](https://docs.google.com/spreadsheets/d/1JVQzq20raZGwxnjsJhLjBrMDswOHL028dwPXdIHoeOQ/template/preview). It does seem that the transactions are missing information about accounts and dates, which could be a little limiting if you wanted to generate a report or a dashboard for a particular period of time. Again, a great starting point, and if it resonates with your kind of setup, it's definitely worth duplicating and playing with. Both templates are free to access and replicate.
+
+Incidentally, if you don't use Notion and are hesitant to try YNAB, you could take a look at [their guide to building your own budgeting template](https://www.youneedabudget.com/how-to-create-a-budget-template/) — this does not require using YNAB at all and can even be made to work pen and paper. Many people have also recreated YNAB's core features using their own favourite tools, the most popular among which appears to be Google sheets — see, for example: [Aspire Budget](https://aspirebudget.com) (c.f. [r/aspirebudgeting](https://www.reddit.com/r/aspirebudgeting)) — I have not tried this myself, but it appears to be very feature-rich and neat overall.
+
+That said, onto our own YNAB-esque budgeting template in Notion! We're on our way to something that looks like this:
+
+![Categories](Screenshot_2021-09-18_at_9.11.50_PM.png)
+
+If you want to just skip ahead and play with the template, you can duplicate it by following [this link](http://42templates.notion.site/Template-Envelope-Budgeting-in-Notion-447cacf529dd4149b18317460b8f9805):
+
+There are three key pieces to this setup: the first is the categories (these are the labels on the envelopes, if you like), the second is the actual transactions that take take place, and the third is a list of accounts that you have (could be bank accounts, credit accounts, virtual wallets, and so on). You would want the transactions database to be linked to both categories and the accounts. More on the exact table designs below. I'm going to assume some familiarity with Notion terminology, if this is your first time with Notion then some of this may not make sense right away, but if you could just [look up how Notion databases work](https://www.notion.vip/how-to-create-your-first-relational-database-in-notion/) — especially the relational aspect — then I think you'd have all you need to follow along!
+
+## Budgeting Categories
+
+
+It may be natural for this table to just have one row for each category. You probably want to have a small number of higher-order categories (e.g: monthly supplies, services, maintenance, health, investments, etc.) and smaller, more specific ones under these broad umbrellas (e.g, services would likely have sub-categories along the lines of internet, phone, electricity, water, etc.). You can do this by setting up a relation property to the table itself, and have it sync two-way, like so:
+
+![Screenshot 2021-09-18 at 3.29.11 PM.png](Screenshot_2021-09-18_at_3.29.11_PM.png)
+
+<aside>
+⚡ We want to make a database that captures the categories that our expenses fall under, and the budget that's available for these categories.
+</aside>
+
+If you want to see just the higher-order categories nicely, you can setup a gallery view with a filter for the main category to be empty, which would look like this (I've disabled the preview and added some [icons from notion.vip](https://www.notion.vip/icons/)):
+
+![The Gallery View](Screenshot_2021-09-18_at_3.33.56_PM.png)
+
+Next, we want to specify a budget for each of these categories. We can do this directly for the lower-order categories first. Then, we can have the main category budgets calculated automatically by rolling up the budgets of the corresponding child categories and adding up their budget values. To have a clean view of the budget, you could add a formula column that just adds up the values from the direct budgets and the rollup, like so:
+
+![Budget View](Screenshot_2021-09-18_at_8.18.35_PM.png)
+
+You can add two dummy properties with the text `Budgeted:` and `Remaining:` for each row, and set them to show along with the budget in the Gallery view so you get something like this:
+
+![Budgeted and Remaining Labels](Screenshot_2021-09-18_at_3.43.12_PM.png)
+
+There are two natural questions at this point:
+
+- How do we know that we have budgeted what we actually have?
+- How do we know what amounts are remaining at any given point of time in the month?
+
+To address both of these questions, we will need to flesh out the transactions database, link it to the categories and come back to this. But before that, let's do a quick detour with an accounts database just to setup the foundation we need for the transactions database.
+
+## Accounts
+
+For this demonstration, I am just going to add two accounts — one savings bank account and one credit card account:
+
+The most natural property we want for the Accounts database would be a *balance* column. Instead of maintaining this manually, we will just link this with the transactions database and derive the balance by rolling up the relevant transactions.
+
+![Accounts View](Screenshot_2021-09-18_at_9.49.12_PM.png)
+
+
+<aside>
+⚡ The accounts database simply has one row for every account you have — these could be savings accounts, credit card accounts, a cash account, or your virtual wallets.
+</aside>
+
+
+## Transactions
+
+You might want to optionally add a memo property that lets you add a quick note or explanation for the transaction. However, given that each database entry is also a page, you could also quite flexibly add all the additional information you want to the page corresponding to any transaction. Meanwhile, you might also want to setup relations to other parts of your Notion setup if you find anything relevant — for instance, if you have a books database, or an inventory database, and so on. That said, we're going to keep it simple here, and here's an example transaction:
+
+![An Example Transaction](Screenshot_2021-09-18_at_4.56.45_PM.png)
+
+<aside>
+⚡ Every transaction has the following: an amount, a payee, the account to which the amount was debited or credited to, the date the transaction happened, and and the expense category that the transaction belonged to. We set these up as columns with the appropriate properties, with the accounts and categories being relational links.
+</aside>
+
+You'll notice that I've linked to both the child and the parent category for this transaction. It would be nice if the parent category was pulled up automatically — and this is possible with a formula, but as far as I know the formula will not actually *link* the transaction to the main category. So for now, we assign both categories manually. 🤷‍♀️
+
+One quick thing to do now is to go back to the Accounts database and add a rollup property that takes on the sum of the amounts property from the related transactions table, and once done, the balances show up nicely in the gallery view:
+
+![Rollup sum of amounts in accounts](Screenshot_2021-09-18_at_4.35.18_PM.png)
+![Gallery view of balances](Screenshot_2021-09-18_at_4.37.52_PM.png)
+
+Now we go back to our categories database and rename the relational column to **transactions** and add a rollup that collects all expenses from the transactions that happened in a particular category, so this is what it looks like:
+
+![Category view](Screenshot_2021-09-18_at_5.50.57_PM.png)
+
+Now add a formula column **available** that simply adds up the budget and the expense columns so you can find out how much of your budget is still available for use. My formula looks like this:
+
+`prop("Final Budget") + prop("Expenses")`
+
+Note that it might feel more natural to subtract expenses, but my expenses are already negative amount transactions, so I just need to bundle it all together.
+
+![Category View](Screenshot_2021-09-18_at_6.30.27_PM.png)
+
+Just for fun, you could also add a **status** column that visually indicates how much of your budget you have left. The progress-bar style of the status property here is inspired [by this guide](https://www.notion.vip/notion-formulas-create-a-progress-bar/), and the formula I used requires a couple of auxiliary columns that calculate the percentage and determine if a half-star should be used or not based on the value of the decimal part. It also first checks that the available balance is in fact positive, if not, it's going to display a suitably scary warning emoji. I won't bore you with the specifics here, but you can find the formula in the template that I've linked to at the end of this post.
+
+So now we are at a point where the remaining amounts are calculated based on the transactions. However, we still have to think about how to link the budgeted amounts to the actual money available. In fact, speaking of money available, I haven't really touched upon how to handle transactions that are not expenses; i.e, transactions with a positive amount value and that reflect money coming *into* the system as opposed to leaving it. These are, of course, just regular transactions — but what category do we assign them to? All the ones we have so far really capture spends, not inflows...
+
+So, it turns out that YNAB would take all this money and automatically categorize it as unassigned, or to be budgeted. We can mimic this by creating a special category called `to be assigned`, and have all income-type transactions categorized as such. Typically this would be transactions corresponding to a salary, client payments, refunds, credit from interest, and so forth.
+
+![The TBA Category](Screenshot_2021-09-18_at_6.38.19_PM.png)
+
+Notice that the so-called **expenses**[^1] that are now accumulating in this category is actually the total amount of money that came into the system. Incidentally, if you were to just look at the sum of the **balance** column in the accounts database, that's the net amount of money in the system at any given point of time.
+
+---
+
+[^1]: Remember that the expenses column just rolled up the transaction amounts in a particular category.
+
+
+![Accounts View](Screenshot_2021-09-18_at_6.42.06_PM.png)
+
+<aside>
+⚡ Note that transactions that just move money within your accounts, like a credit card payment, don't need any explicit expense categories.
+</aside>
+
+You also don't need to budget separately for credit card payments, because your credit card bill is composed of transactions that were already budgeted for! Even if they were items corresponding to, say, credit card fees, you probably categorized them under Services, for example. So we won't have a separate budget for credit card bill payments (although I should mention that YNAB does this explicitly and handles it automatically).
+
+Alright, so it seems like we are nearly there, except that our current situation is the following:
+
+1. The amount the *to be assigned* category is a true reflection of incoming funds.
+2. The amounts that we added to our category budgets were setup manually and generally divorced from the reality in the transactions database.
+
+<aside>
+⚡ To fix this, we need some way to move funds from the *to be assigned* category to the other ones.
+
+</aside>
+
+For example, let's say I want to budget 750 for ebooks this month. I could do this by adding a dummy transaction that debits an amount of 750 to the *to be assigned* category and credits it to the *ebooks* category*.* What this means is that when we roll up the amounts from all transactions, we directly obtain the amount remaining for us to spend!
+
+So for the very first month, when we have a clean slate, we just have a bunch of such transactions — these won't have any explicit account associated with them because they aren't real transactions; and in fact you can always filter your transactions table so that you only see the meaningful ones by setting the condition that the accounts column should be non-empty.
+
+Meanwhile, here is how we do the budgets for our categories all over again, this time via these virtual transactions:
+
+![Budget Overview](Screenshot_2021-09-18_at_9.57.40_PM.png)
+
+If you go to the *to be assigned* row in the categories table and look at the rollup value in the expenses column, then you'll see that it corresponds to either the amount of money that's still assigned (these are dollars — or in my case, rupees — that don't have a job yet), or, in case you happen to have overshot the budget, the amount by which you are falling short. In the former situation, the available amount will be a positive number, while in the latter, it'll be negative.
+
+![To Be Assigned](Screenshot_2021-09-18_at_7.57.35_PM.png)
+
+Ideally, we just want this number to be *zero*, indicating that everything has been assigned appropriately. To achieve this:
+
+1. If your budgets have collectively overshot the amount of money available, re-adjust them them — specifically, reduce some of the amounts — so that this is no longer the case. Of course, I am saying this from a theoretical standpoint; if your situation is that you have real expenses that you don't have real money for, then you would want to plan for this by bringing the differential amount of money into the system via a loan, and then planning the repayment by budgeting for it as well. Dealing with debt is beyond the scope of this discussion, but I think the [YNAB blog](https://www.youneedabudget.com/blog/), [book](https://www.youneedabudget.com/ynab-the-book/), and [videos](https://www.youtube.com/user/youneedabudget) go into this at length.
+2. If you have money left over, you could either add it to your budgets, giving yourself some extra wiggle room; but I prefer to budget for fixed amounts generally, so in this situation I'll just add this amount to something I call a *Miscellaneous* or *Scratchpad* category. It's something you can borrow from if you fall short later, it has no particular semantics. Some people like to sweep off any excess money into deposit accounts, and if you do this, then you might want to create those accounts in the system and enter those transactions to get rid of this positive balance.
+
+At the end of this, you are in a situation where all money is nice and assigned. Since we started off by specifying budgets manually, we should go back and fix some formulas in our database of categories. In particular, here's what I did to simplify things:
+
+- Remove the `Available` column (previously this was the difference of the manually set budget and the rolled up expenses).
+- Rename `Expenses` to `Available`, since the rollup now just reflects what's truly available.
+
+I'm going to leave the manually added budgets in — although we won't use them to calculate what's truly available any more, they will help us plan our budgets going forward.
+
+Everything so far should make sense for an initial setup, but what do we do when we have new incoming transactions that need to be assigned to categories? I generally like to do the budgeting exercise once at the start of every month, so any intermediate positive transactions into the system will either remain in the *To be assigned* category, or if you are OCD about wanting that that category to be set to zero always, you can always push this number out into your scratchpad.
+
+At the start of the month (this could be another day and a different frequency; but I do recommend being consistent for simplicity), we need to refuel the categories with the funds available. There are two kinds of things that could happen here, broadly speaking:
+
+1. For categories that represent a plan to save up to something, like a vacation, or a category where you feel like you want to have a certain amount of money set aside every month irrespective of how much you spent in the last month, you just want to push `budget` amount of money into that category via the virtual transactions we discussed earlier.
+2. For other categories, which I like to think of as those having *rolling* budgets, you want to only assign the difference between what was budgeted and what was spent... and hopefully this is a non-negative quantity!
+
+You could setup a checkbox to indicate which categories have rolling budgets and which ones do not, and then this formula:
+
+`prop("IsRolling?") ? (prop("Budget") - prop("Available")) : prop("Budget")`
+
+will tell you how much you should budget for next month.
+
+![In this example, Ebooks are not a rolling category, so even though I need only 628.95 to meet the original budget, I'll still set aside the full 750, and the amount that will be available will be 871.05. On the other hand, Phone is a rolling category, and presumably my phone-related expenses in the current month added up to 420, so the recommendation is to budget 420 next time so you'll still have 500 available total. ](Screenshot_2021-09-18_at_8.23.47_PM.png)
+
+In this example, Ebooks are not a rolling category, so even though I need only 628.95 to meet the original budget, I'll still set aside the full 750, and the amount that will be available will be 871.05. On the other hand, Phone is a rolling category, and presumably my phone-related expenses in the current month added up to 420, so the recommendation is to budget 420 next time so you'll still have 500 available total.
+
+## The Process After Setting Up
+
+There are two main times that you'll interact with this budget: whenever a transaction is made, and once every X days to reset the budgets for the individual categories.
+
+Adding transactions is reasonably easy, although admittedly it's probably not as smooth as a specialized app that might have a Siri command to do this for you or a widget that let's you quick-add things. However, it's not too bad, especially if you enter it right away. You could also potentially automate this via API integrations, or enter your transactions in your regular app and export them as a CSV and import them into the Notion system once every so often.
+
+![Transaction Table](Screenshot_2021-09-18_at_8.37.56_PM.png)
+
+The budgeting bit is going to be a little more work, especially if you work with a gazillion categories. The formulas will guide to you what needs to be done, but those virtual transactions still need to be added manually. On YNAB, you can do what I described above (adding the deficit to rollup categories and the originally intended budgets to the others) in one click — and there are other options too, for example, you may have moved to a new location and you're still getting the hang of what you'll need to set aside for groceries, so YNAB will offer to budget what you spent last month, or your average expenses from the last six months, and so on. Here, since you are assigning things manually, you can definitely tweak as you go; the **next month** column is just a suggestion.
+
+You can probably prepare a CSV file with the default budget amounts and just merge this in at the start of every month if your expenses are super predictable, and just adjust the entries that need adjusting. This will save you some time, but remember that the categories still need to be linked to manually. It's not too bad for something that happens once a month and that will hopefully bring you some sense of control and awareness 😇
+
+Perhaps also try and not have a gazillion categories and sub-categories, at least to begin with — it helps to keep things simple, especially when starting out.
+
+## Common Pitfalls
+
+Here are a couple of mistakes I made frequently, even while just setting up this template!
+
+- Forgetting that transaction amounts corresponding to expenses should be recorded as negative numbers! If this happens very very frequently to you, you could also set this up a little differently — have a checkbox to indicate if a transaction is an expense or an inflow, and always enter a positive number reflecting the amount, and let a formula do the work of adding the sign!
+- Forgetting to add the parent category — this can mess up the views of what's available in the high-level categories and cause the numbers to not tally. So if you need to debug your numbers, check for whether you have added both categories to your transactions or not!
+
+## Dashboards
+
+Most of the action here is happening in the Transactions database. You could create linked copies of this database anywhere you like and filter things out to see what you want. For instance, if you want to keep tabs on the transactions in specific accounts, you could have this on your account pages:
+
+![Account Overview](Screenshot_2021-09-18_at_8.47.47_PM.png)
+
+You could filter out transactions for a particular month, a particular category (either a top-level category or an atomic one), and so on. I think there's plenty you can do here, but I am not sure how much of this can be automated. For instance, you might want to generate — or have over email — a monthly report of your expenses across various categories and how did relative to your estimated budgets. This should be possible by leveraging the API and tools like Integromat/Zapier/Automate.io - but I haven't really explored the possibilities here.
+
+## Missing Features
+
+It would be nice to have a gallery view of the months of the year showing spends and budgets in each (high-level?) category. For this though I'd need the rows to correspond to months, columns corresponding to categories, which pull up transactions that happened in a particular month from said category.
+
+Even if I manually linked the transactions database to this calendar one, and made sure each transaction was linked to the correct row, I don't see how I can split up those transactions across categories, since it's not possible to add a filter to relational columns or rollups as far as I know. It's a similar bottleneck going through the Categories database as well. This information is of course implicit in the system, I just can't think of a neat way of visualizing it.
+
+This is possible to do for the current month though:
+
+![Monthly Overview](Screenshot_2021-09-18_at_9.08.56_PM.png)
+
+YNAB also has more sophisticated category types — apart from budgets that roll or accumulate, you could have categories that aim to have a certain amount of funds assigned by a certain date and so on. For those who are freelancers with incomes spread over the days of the month, I think YNAB has a lot of little features that allow for a more flexible way of budgeting, which I'm not super familiar with because I'm not in this situation. This is just to say that this setup here may be both limiting and feeing because of how much of the setup is manually done. At least that's my optimistic view right now 😀
+
+Finally, YNAB also has an option to reconcile accounts, which is when you declare that the numbers in YNAB match the book balance according to your bank or credit card agency. This is a neat little thing that I like to check off every so often. Here, I suppose you could just glance through the balances on the Accounts database (remember the gallery view from earlier?), but it won't have the same song-and-dance-y feeling — but maybe this could be a recurring task that you can check off, and hopefully *that* will feel good 😅
+
+So that's about it! I'd love to hear any feedback on this, and suggestions for improving the setup would be very welcome too. You can duplicate the template [from here](https://www.notion.so/Template-Envelope-Budgeting-in-Notion-447cacf529dd4149b18317460b8f9805).
diff --git a/sites/reviews/src/content/reviews/massren/20180528-screen-massren.gif b/sites/reviews/src/content/reviews/massren/20180528-screen-massren.gif
new file mode 100644
index 0000000..ebbeaf7
Binary files /dev/null and b/sites/reviews/src/content/reviews/massren/20180528-screen-massren.gif differ
diff --git a/sites/reviews/src/content/reviews/massren/index.md b/sites/reviews/src/content/reviews/massren/index.md
new file mode 100644
index 0000000..ecf0387
--- /dev/null
+++ b/sites/reviews/src/content/reviews/massren/index.md
@@ -0,0 +1,28 @@
+---
+title: "Massren for fast file renaming"
+description: "My tool of choice for bulk file-renaming has become[^1] Massren: [^1]: As opposed to, say, GUI clients. Massren is a command line tool that can be used to rename multiple files..."
+pubDate: "2020-09-11"
+authorName: "Neeldhara"
+sourceCategories: ["workflows"]
+sourcePath: "massren/index.qmd"
+---
+
+My tool of choice for bulk file-renaming has become[^1] [Massren](https://github.com/laurent22/massren):
+
+[^1]: As opposed to, say, GUI clients.
+
+> Massren is a command line tool that can be used to rename multiple files using your own text editor. Multiple-rename tools are usually difficult to use from the command line since any regular e
+xpression needs to be escaped, and each tool uses its own syntax and flavor of regex. The advantage of massren is that you are using the text editor you use every day, and so you can use all the features you are already used to.
+>
+
+Simply navigate to the directory in which your files are and invoke massren. You can easily set it up to use your favorite text editor, so for example, I have mine configured to use VSCode:
+
+```
+massren --config editor code
+```
+
+If you have a text editor you are comfortable with, then this can lead to all kinds of interesting possibilities, especially when combined with regular expression search.
+
+![Using Massren, VS Code, and regex for bulk file renaming.](20180528-screen-massren.gif)
+
+This workflow is especially convenient in combination with an Alfred wokflow to open the current Finder directory in the terminal, such as [this one](https://github.com/LeEnno/alfred-terminalfinder).
diff --git a/sites/reviews/src/content/reviews/mechanical-keyboard.md b/sites/reviews/src/content/reviews/mechanical-keyboard.md
deleted file mode 100644
index 0346a78..0000000
--- a/sites/reviews/src/content/reviews/mechanical-keyboard.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "ZSA Moonlander: Ergonomic Keyboard for Coders"
-description: "Six months with a split ergonomic mechanical keyboard - the good, the bad, and the RSI relief."
-pubDate: "Feb 20 2024"
-image: "https://images.unsplash.com/photo-1587829741301-dc798b83add3?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# ZSA Moonlander: Ergonomic Keyboard for Coders
-
-After years of wrist pain, I took the plunge into ergonomic mechanical keyboards.
-
-## The Learning Curve
-
-Week 1: 20 WPM and questioning life choices
-Week 2: 40 WPM and seeing the light
-Month 2: Back to 80 WPM with no wrist pain
-
-## The Good
-
-- Columnar layout makes sense once muscle memory adapts
-- Thumb clusters are game-changers for shortcuts
-- The configurability is endless (perhaps too endless)
-
-## The Investment
-
-At $365, it's expensive. But compared to physical therapy or career-limiting injury? Bargain.
-
-## Who Should Buy This?
-
-If you type for a living and feel any discomfort, don't wait. Your future self will thank you.
diff --git a/sites/reviews/src/content/reviews/new-mac/index.md b/sites/reviews/src/content/reviews/new-mac/index.md
new file mode 100644
index 0000000..f711e7b
--- /dev/null
+++ b/sites/reviews/src/content/reviews/new-mac/index.md
@@ -0,0 +1,302 @@
+---
+title: "New Mac"
+description: "Here's a list of 50 things[^1] (with occasional additional context) that I install whenever I'm setting up macOS from scratch. [^1]: NB. This list does not include fonts and scr..."
+pubDate: "2021-09-30"
+authorName: "Neeldhara"
+sourceCategories: ["apps", "lists"]
+sourcePath: "new-mac/index.qmd"
+---
+
+Here's a list of 50 things[^1] (with occasional additional context) that I install whenever I'm setting up macOS from scratch.
+
+[^1]: NB. This list does not include fonts and scripts — that's for a separate round up in due course.
+
+> **Note**
+> 
+> ## via Setapp
+> 
+> 1. Bartender
+> 
+>     Keeps the menubar clean. Very handy!
+> 
+> 2. Better Touch Tool
+> 
+>     I really need to leverage this a lot more, but even simple actions like swipe down with three fingers to close a tab, or tip-tap right left to move between tabs is pretty awesome already. Also use four-finger double tap to make the mouse pointer larger when it's lost between screens... I'd guess this app can probably subsume a lot of the functionality offered by apps like Keyboard Maestro and Alfred.
+> 
+> 3. iStat Menus
+> 
+>     Good-looking stats in the menubar 👍️
+> 
+> 4. Yoink
+> 
+>     Has to be one of the best shelf apps out there. I know that there are a bunch of others in this space right now (👀, Filepane), however I have been using Yoink for so long that I haven't considered switching. My common use-cases:
+> 
+>     - Alfred actions to send-to-Yoink
+>     - Using Yoink to stash away screenshots before the floating image disappears
+>     - A KM shortcut that can send any Finder item to Yoink
+> 
+> 5. CleanMyMac
+> 
+>     Mostly to keep track of file sizes via the Space Lens, and running cleanups once in a while.
+> 
+>     Alternative if using only this feature: Daisy Disk
+> 
+> 6. Default Folder X
+> 
+>     Use this all the time to stash away stuff where it belongs to keep Downloads clutter-free. Also the Alfred DFX collection is handy for finding recent items even if not 100% reliable.
+> 
+> 7. Timing
+> 
+>     Use this to supplement manual time-tracking. Do not use it to its full potential at all, I think a little investment with setting up the right projects etc. can go a long way.
+> 
+> 8. Dropzone
+> 
+>     I mostly use this as a longer-term stash than Yoink. I think there are some very nice possibilities here, but the only things I've done with it so far include:
+> 
+>     - uploading images online
+>     - opening a finder path in a terminal (superseded by an Alfred shortcut)
+>     - dropping files in select locations
+>     - URL shortening
+> 9. Permute
+> 
+>     Handy for all kinds of (bulk) file conversions.
+> 
+> 10. Text Sniper
+> 
+>     Impressive OCR "from anywhere". The newer releases of macOS may make this redundant eventually though.
+> 
+> 11. Swish
+> 
+>     Intuitive gestures for window management. Pretty confident all this can be done in Better Touch Tool (above), but the actions are inspiring, and I'm lazy, so yeah, this is explicitly installed.
+> 
+> 12. Downie
+> 
+>     Use this for downloading videos from Youtube for offline viewing/listening. Fairly robust.
+> 
+> 13. IconJar
+> 
+>     Icon collection, enough said. 🎁
+> 
+> 14. Sip
+> 
+>     Handy 🎨  color picker.
+> 
+> 15. World Clock Pro
+> 
+>     Visually appealing world-clock, nice for scheduling stuff across timezones, great screensaver option as well.
+> 
+> 16. Dash
+> 
+>     Documentation lookup, handy that it works inside VS Code (via an extension).
+> 
+> 17. MindNode
+> 
+>     Lovely mindmaps.
+> 
+> 18. PDFPen
+> 
+>     Although I mostly use Preview, PDFPen is useful for quickly rearranging and removing pages. Not sure about the several other features claimed, I find that it sadly crashes more often than not, so not my default application.
+> 
+> 19. TextSoap
+> 
+>     Occasional use, but very useful when I do need it for some pesky hidden-unicode-character-removal exercise.
+> 
+> 20. MathKey
+> 
+>     Niche app - on the rare occasion that I have a complicated LaTeX formula to write, I can write it in the iOS version of this app and receive it on the Mac (I don't think the desktop app is even necessary for this; the iOS purchase can be bypassed by using the Mac app via Sidecar, but this is where I discovered the app so it makes the list).
+> 
+> 21. Marked
+> 
+>     Powerful previews for Markdown documents. Lots of interesting export features.
+> 
+> 22. ChronoSync Express
+> 
+>     This helps with keeping certain folders in sync, and setting up some backup schedules. Nothing that can't be done with a few scripts (?) and/or Time Machine, but I did end up setting (and forgetting) a few things in here.
+
+
+> **Note**
+> 
+> ## General
+> 
+> 1. Notion
+> 
+>     I'm (admittedly* experimentally) using Notion as my primary PKM tool, and it's also where I am keeping most of my public-facing content (including this blog). My usage of Notion is gradually expanding in scope to include time/task/finance tracking as well. Too slow.
+> 
+>     *I've been in and out of Notion a few times by now, interleaved with fairly committed detours through Obsidian, Craft, and VSCode extensions for several months... I should mention that Craft is now available through Setapp, and that I am tentatively moving to Obsidian.
+> 
+> 2. Bibdesk
+> 
+>     Fairly robust reference management that has most of what I need — priority features include speed, reliability, flexibility in generating citekeys and decent auto-filing of papers added to the database (popular free and paid alternatives that I've tried briefly: Zotero, Mendeley, Setne, Papers, Readcube, JabRef, Bookends).
+> 
+>     Incidentally, if you are into Obsidian and Zotero, you might enjoy [this video](https://www.youtube.com/watch?v=XbGJH08ZfCs).
+> 
+> 3. MacTeX
+> 
+>     LaTeX and related tools, including TeX-friendly IDEs and reference management tools.
+> 
+> 4. Xcode Tools, pandoc, and homebrew
+> 
+>     Need these to work with code.
+> 
+> 5. Contexts
+> 
+>     The app that I miss the first when on a machine that doesn't have it, next to Alfred. Makes window switching much more search and keyboard-driven.
+> 
+> 6. Alfred
+> 
+>     Apart from using it as a launcher (even for files), I almost use Alfred as a Finder replacement. Here are some of my favorite Alfred workflows:
+> 
+>     - Menubar Search
+>     - Simple Folder Search (only search for folders)
+>     - Case Switch (combined with send-text-to-Alfred below, this can be quite nifty)
+>     - Symbols Search (unicode goodness)
+>     - Send to Yoink
+>     - Quit Applications
+>     - Send text to Alfred (double-tap the option key)
+>     - Color
+>     - Currency Exchanges
+> 
+> 7. Keyboard Maestro
+> 
+>     Really elaborate shortcut/automation app. I've only scratched the surface with my use cases, but one of the things I really dig about my setup is simulating keypress sequences.
+> 
+>     The way I do this is to activate a macro group for one action with one keyboard shortcut (e.g, CMD + ;) and then have all macros within that have one-letter or one-letter + one-modifier triggers - basically *very easy triggers.* This way, I only have to remember a bunch of high-level shortcuts for things in various categories, and from there it's just a letter (and the same letter can be overloaded in different contexts).
+> 
+>     As a concrete example, I have a macro group called launchers, and a shortcut within that for launching chrome. So something like CMD+L followed by c would launch Chrome. Although I have to confess that I mostly launch stuff through Alfred still (at the cost of one or two extra keystrokes).
+> 
+>     Keypress-sequence-triggers are native to Better Touch Tool and since BTT supports AppleScript, you could also run KM macros from BTT. I haven't quite tried this yet.
+> 
+>     More advice on this [here](https://wiki.keyboardmaestro.com/Frequently_Asked_Questions#How_do_I_use_a_multiple_keystroke_trigger).
+> 
+> 8. Typinator
+> 
+>     Fast snippet expansion - faster than TextExpander (one of the main competitors in this space) in my experience. Recent updates have some rad features, which of course I'm yet to explore and exploit!
+> 
+> 9. 1Password
+> 
+>     Reasonably user-friendly and robust password management. Syncs to iOS, but I haven't managed to leverage it so much on iOS. 1Password is ideal for storing confidential information nicely (IDs, bank stuff, and the like) - if used only for passwords I suppose the Keychain does a good job too.
+> 
+> 10. Fantastical and Calendar
+> 
+>     Fantastical is a nice (but expensive!) calendar app, mostly use it because of the calendar sets feature that keeps my [time blocking calendars](https://www.macsparky.com/blog/2018/2/hyper-scheduling-mechanics) separate from the official one that is public within the organization. Of late, I especially like the way you can join online meetings from the notifications.
+> 
+>     ~~Having said that, I realized that much of what I was doing with Fantastical was overkill and I've switched to the default calendar app for now, and it's one paid subscription less[^2] to have.~~
+> 
+>     Oh well: so I am back on Fantastical, I guess I really like the UI! Meanwhile, Busycal is a great alternative if you are on Setapp.
+> 
+>     [^2]: I have nothing against paid subscriptions for software in general, but Fantastical's pricing for the feature set does seem to have an unclear cost-benefit tradeoff, at least for users like me. I haven't missed much since moving on.
+> 
+> 11. VS Code
+> 
+>     This is where I am supposed to be spending most of my time, perhaps next only to Craft/Notion. A few things from my VSCode workflow:
+> 
+>     - Use different themes for different file types (I mostly dabble in LaTeX, C++, Python, JavaScript, and Markdown)
+>     - Little utility extensions save a lot of time: e.g, sort lines, increment value at cursor, file management, etc.
+>     - Multicursor-powered find and replace is amazing.
+>     - Workspaces are handy and I usually launch them from Alfred.
+> 
+> 12. Hook
+> 
+>     Looks very promising for cross-linking stuff across apps that have a common context (say, a project). I really need to explore this more!
+> 
+>     Update: Hook is now Hookmark, and is alo available through Setapp.
+> 
+> 13. Stream Deck (best with accompanying hardware)
+> 
+>     Particularly useful for switching OBS scenes although I use it less than I thought I would!
+> 
+>     In particular, I want to explore their VSCode and KM integrations.
+> 
+>     If without the physical device, Streamdeck does have a nice iOS app that simulates the hardware, but the pricing is based on a subscription model.
+> 
+> 14. Google Chrome
+> 
+>     I can't make up my mind between Chrome/FF/Brave/Safari. I mostly switch between Chrome and Safari, with a mild preference for Chrome because of it's more comprehensive extensions space, but I often end up with Safari as default for speed and privacy.
+> 
+> 15. Readkit
+> 
+>     Use this for RSS, although I’ve mostly migrated away to DEVONthink. Still looking for a nice stand-alone RSS reader though, Readkit doesn't always render everything the way I expect, sadly.
+> 
+> 16. OBS
+> 
+>     For recording and live-streaming videos. Also useful as a virtual camera for meeting apps.
+> 
+> 17. Screenflow and Camtasia
+> 
+>     For recording videos, lots of features, still finding my way around them.
+> 
+> 18. Slack and Discord
+> 
+>     Online communities. I sometimes wish there was a native app for discourse too (is there?)
+> 
+> 19. Keynote
+> 
+>     Presentations - main alternative: Beamer + LaTeX + pgf/TikZ; or one of the JS-based slide generator tools from Markdown files (I did use react.js for one entire term).
+> 
+> 20. DEVONthink
+> 
+>     Use this fairly minimally (especially relative to the possibilities). At the moment DT indexes a couple of key finder folders and pulls in information from a lot of RSS feeds and even Twitter accounts. I try to review the stuff that automatically piles up in DT regularly, but — at the moment — it's mostly a dumping ground and... messy.
+> 
+> 21. Microsoft Teams, Skype, and Zoom
+> 
+>     Use this for classes and online meetings.
+> 
+> 22. Office suite: Word/Powerpoint/Excel
+> 
+>     Use it only to open files I receive.
+> 
+> 23. Fruitjuice
+> 
+>     Useful battery health monitoring, discovered the app from a MPU podcast episode IIRC.
+> 
+> 24. Mathsnip
+> 
+>     Surprisingly good LaTeX-aware OCR.
+
+
+> **Note**
+> 
+> ## Webapps
+> 1. YNAB
+> 
+>     Budgeting and finance management.
+> 
+> 2. Gmail
+> 
+>     Until I setup Mailmate again, I'm checking email in my browser. 🙈
+> 
+> 3. GSuite (Docs, Sheets, Slides, and Calendar)
+> 
+>     I use these when others use them.
+> 
+> 4. Zapier, IFTTT, Integromat
+> 
+>     A few automations here and there, still on my bucket list to take full advantage here. Integromat has been great for [tracking Exportober](https://www.notion.so/Tracking-Exportober-2416e14ae9254bc0b97532f73058b1bb) contributions, incidentally!
+
+
+> **Note**
+> 
+> ## Omissions
+> 
+> (aka stuff I used to use but don’t use as much now.)
+> 
+> 1. Karabiner Elements. I was quite taken in by the possibilities offered by [“God Mode”](https://medium.com/@nikitavoloboev/karabiner-god-mode-7407a5ddc8f6), but I realised that I prefer sequential shortcuts - like the ones I managed to setup in KM - to ones powered by arbitrary combinations of simultaneous keypresses.
+> 
+> 2. Mailmate. Will very likely be back in the workflow soon!
+> 
+> 3. Things. Retired when I switched to “Notion for Everything”. That said, Things is absolutely awesome!
+> 
+> 4. Ulyssess. Replaced by Notion → Craft → Obsidian → Notion.
+> 
+> 5. Bear. Replaced by Notion → Craft → Obsidian → Notion.
+> 
+> 6. Sublime Text. Replaced by VSCode.
+> 
+> 7. 2Do. Replaced by Things a long time ago, but a really nice app!
+> 
+> 8. Shift. Combines many windows in one, basically. Not sure if it was sufficiently useful, living without it and not missing it much.
+> 
+> 9. IM+. Similar to Shift in scope, although this one is available on Setapp.
+
+
+What’s on your list? Do share in the comments below!
diff --git a/sites/reviews/src/content/reviews/note-taking-resources/index.md b/sites/reviews/src/content/reviews/note-taking-resources/index.md
new file mode 100644
index 0000000..9ab6383
--- /dev/null
+++ b/sites/reviews/src/content/reviews/note-taking-resources/index.md
@@ -0,0 +1,14 @@
+---
+title: "Note Taking Resources"
+description: "Here is a list of courses, books, essays, youtube playlists, and other miscellany about taking notes, with the act interpreted broadly to include things like systems for filing,..."
+pubDate: "2023-06-02"
+authorName: "Neeldhara"
+sourceCategories: ["lists"]
+sourcePath: "note-taking-resources/index.qmd"
+---
+
+Here is a list of courses, books, essays, youtube playlists, and other miscellany about taking notes, with the act interpreted broadly to include things like systems for filing, organization, linking, and thinking. Please feel free to drop a line in the comments or send a PR my way if you have something to add!
+
+Thanks to [Abhinav](https://twitter.com/abhinav) for [the prompt](https://twitter.com/abhinav/status/1664359012467441664?s=20) :)
+
+<br><br>
diff --git a/sites/reviews/src/content/reviews/note-taking-resources/resources.ejs b/sites/reviews/src/content/reviews/note-taking-resources/resources.ejs
new file mode 100644
index 0000000..2d07e60
--- /dev/null
+++ b/sites/reviews/src/content/reviews/note-taking-resources/resources.ejs
@@ -0,0 +1,34 @@
+```{=html}
+<table class="quarto-listing-table table">
+    <thead>
+        <td class="listing-type" style="max-width: 42px !important; text-align: center;">Type</td>
+        <td class="listing-type" style="max-width: 42px !important; text-align: center;">Link</td>
+        <td>Resource</td>
+    </thead>
+    <tbody class="list">
+    <% for (const item of items) { %>
+        <tr data-index="0" data-categories="null" <%= metadataAttrs(item) %>>     
+            <td class="listing-type" style="max-width: 42px !important; text-align: center;">
+                <strong><% if (item.type == "youtube") { %> <span class="bi bi-youtube"></span> <% } %> 
+                <strong><% if (item.type == "book") { %> <span class="bi bi-book"></span> <% } %> 
+                <strong><% if (item.type == "course") { %> <span class="bi bi-journal-bookmark"></span> <% } %> 
+                <strong><% if (item.type == "MOC") { %> <span class="bi bi-map"></span> <% } %> 
+                <strong><% if (item.type == "other") { %> <span class="bi bi-stars"></span> <% } %> 
+                <strong><% if (item.type == "essay") { %> <span class="bi bi-card-text"></span> <% } %> 
+                <strong><% if (item.type == "software") { %> <span class="bi bi-code-square"></span> <% } %> 
+            </td>
+            <td class="listing-link" style="max-width: 42px !important; text-align: center;">
+                <% if (item.link) { %>
+                    <a href="<%= item.link %>"><span class="bi bi-link-45deg"></span></a>
+                <% } %>
+            </td>
+            <td class="listing-title" style="max-width: 420px !important;">
+                <strong><% if (item.slno) { %><%= item.slno %>.<% } %> <%= item.title %></strong><br>
+                <p><%= item.summary %></p>
+            </td>
+        </tr>
+    <% } %>
+</tbody>
+</table>
+
+```
diff --git a/sites/reviews/src/content/reviews/note-taking-resources/resources.yml b/sites/reviews/src/content/reviews/note-taking-resources/resources.yml
new file mode 100644
index 0000000..efa9e6b
--- /dev/null
+++ b/sites/reviews/src/content/reviews/note-taking-resources/resources.yml
@@ -0,0 +1,100 @@
+- slno: 01
+  title: "Cognitive Productivity: Using Knowledge to Become Profoundly Effective"
+  summary: "Book by Luc P. Beaudoin. <br> Official book summary: You distinguish yourself from others not so much by what you've read, viewed or listened to, but by the lasting impact that information has had upon you. How can you use knowledge to become a more effective person? Cognitive Productivity answers this question with cognitive science and practical strategies."
+  link: https://leanpub.com/cognitiveproductivity/
+  type: book
+- slno: 02 
+  title: "Cognitive Productivity with macOS: 7 Principles for Getting Smarter with Knowledge"
+  summary: "Book by Luc P. Beaudoin. <br> Official book summary: In today's competitive knowledge economy, you always need to keep learning —and fast. But most information and apps get in the way. This book describes 7 principles for selecting, processing and mastering knowledge using potent Mac apps."
+  link: https://leanpub.com/cognitive-productivity-macos
+  type: book
+- slno: 03 
+  title: "The Introduction to the Zettelkasten Method"
+  summary: "Zettelkasten is a rather specific note-taking system (disclaimer: it is not something that I use, but I do find the principles vaguely intriguing). It relies heavily on tagging, linking, going with the flow, not overthinking, and somehow simultaneously keeps things systematic from a retrieval perspective. This overview page has a bunch of pointers that that should serve as a roadmap for the Zettelkasten for anyone inclined to find out more."
+  link: https://zettelkasten.de/posts/overview/
+  type: MOC
+- slno: 04 
+  title: "How can we develop transformative tools for thought?"
+  summary: "Essay by Andy Matuschak and Michael Nielsen <br> Arguably not about taking notes per se, but about philosophies associated with systems and — as the title suggests — tools for thought."
+  link: https://numinous.productions/ttft/
+  type: essay
+- slno: 05 
+  title: "Evergreen Notes"
+  summary: "Thoughts from Andy Matuschak <br>The OG 'digital garden', if I am not mistaken!"
+  link: https://notes.andymatuschak.org/z4SDCZQeRo4xFEQ8H4qrSqd68ucpgE6LU155C
+  type: essay
+- slno: 06 
+  title: "Obsidian for Everyone"
+  summary: "Nicole van der Hoeven's course. <br> Nicole is a pro Obsidian user and a master expositor. This particular course is nice because it focuses on all the things you can achieve without the use of any plugins: just bare-bones Obsidian. You'd be surprised at how far you can go!"
+  link: https://courses.nicolevanderhoeven.com/o4e
+  type: course
+- slno: 07 
+  title: "Youtube channel: Nicole van der Hoeven"
+  summary: "Excellent content for pro and starter Obsidian users alike. Very accessible and engaging, and I believe most people will find something relevant and relatable here."
+  link: https://www.youtube.com/@nicolevdh/playlists
+  type: youtube
+- slno: 08 
+  title: "Grok TiddlyWiki"
+  summary: "Grok TiddlyWiki is written and maintained by Soren Bjornstad. <br> Outstanding introduction to TiddlyWiki. Even non-TW users are likely to get some fun ideas from skimming this. And if you are a TW user, then this is one of the best journeys from starter to pro! Also check out Soren's own digital garden."
+  link: https://groktiddlywiki.com/read/
+  type: book
+- slno: 09 
+  title: "Youtube channel: Linking Your Thinking (LYT)"
+  summary: "This is Nick Milo's Youtube channel. It is mostly principles around linking, but uses Obsidian as the tool of choice. Nick also organizes a LYT conference regularly that is hugely popular and not particularly restricted to Obsidian. He also has a cohort-based course around LYT principles, a great Obsidian starter playlist, and a course called Obsidian Flight School as well."
+  link: https://www.youtube.com/@linkingyourthinking
+  type: youtube
+- slno: 10 
+  title: "Youtube channel: August Bradley"
+  summary: "This channel focuses on 'life design' as a broad concept, using Notion as the underlying tool of choice for organization. There is an extensive discussion of the 'PPV' system - Pillars, Pipelines, and Vaults. Lots of system thinking in here, and I think although all of it is done on Notion, several principles are tool-agnostic."
+  link: https://www.youtube.com/@augustbradley
+  type: youtube
+- slno: 11 
+  title: "Building a Second Brain"
+  summary: "This is a cohort-based course around the notion of building a second brain by Tiago Forte. The material is centered around the 'PARA' method - Projects, Areas, Resources, Archives: a fairly intuitive system that many have found useful. Tiago has one published and one upcoming [at the time of this writing] book on these methods. His blog and Youtube channel dive fairly deep into these concepts, and I think the cohorts are useful if you are building something out and are looking for ways to stay accountable on sticking a system, or want a community/platform to brainstorm ideas."
+  link: https://www.buildingasecondbrain.com/course
+  type: book
+- slno: 12 
+  title: "Youtube channel: Marie Poulin"
+  summary: "Marie is an authority when it comes to adapting Notion in creative ways for both personal and business use. She has a very comprehensive course called Notion Mastery that covers a lot of ground in terms of both techniques and principles."
+  link: https://www.youtube.com/c/mariepoulin
+  type: youtube
+- slno: 13
+  title: "Youtube channel: Zsolt's Visual Personal Knowledge Management"
+  summary: "This is the Zsolt's channel, who is behind tools like Excalibrain and Excalidraw for Obsidian and beyond. The channel emphasizes visual aspects of note-taking, while some of it is focused on Excalidraw/Excalibrain, a lot of content is also about general principles, examples, and so on."
+  link: https://www.youtube.com/@VisualPKM
+  type: youtube
+- slno: 14
+  title: "Youtube channel: Thomas Frank"
+  summary: "This channel is another one that pushes Notion to its limits. While overall this might be more productivity/systems/management territory than note-taking, I have found some great discussions about organizational principles here."
+  link: https://www.youtube.com/@Thomasfrank
+  type: youtube
+- slno: 15
+  title: "Johnny Decimal"
+  summary: "This is purely about organization, but for me how notes are stored are an important piece of the puzzle. If you like folders, you might enjoy this system."
+  link: https://johnnydecimal.com/
+  type: other
+- slno: 16
+  title: "A list of PKM tools"
+  summary: "A reddit post collecting a bunch of PKM software options, ranging from mainstream to exotic and everything in between!"
+  link: https://www.reddit.com/r/PKMS/comments/nfef59/list_of_personal_knowledge_management_systems/
+  type: MOC
+- slno: 17
+  title: "To Obsidian and Beyond"
+  summary: "A course by Mike Schmitz. From the official description: A master-course for Obsidian users (new and old alike). Finally organize your notes and ideas to make creative output easy."
+  link: https://thesweetsetup.com/obsidian/
+  type: course
+- slno: 18
+  title: "Youtube channel: Red Gregory"
+  summary: "A Notion-based channel: I have found some of the workflows here to be advanced and intriguing in equal measure. Many principles are tool-agnostic, although the focus here is mostly on Notion." 
+  link: https://www.youtube.com/c/RedGregory
+  type: youtube
+- slno: 19
+  title: "Youtube channel: Danny Hatcher"
+  summary: "A channel focused on PKM and organizational systems broadly. I have mostly viewed the Obsidian-related material here: several demonstrations and tutorials have been very helpful."
+  link: https://www.youtube.com/@DannyHatcher
+  type: youtube
+- slno: 20
+  title: "Verbal to Visual"
+  summary: "Lots of resources on sketchnoting and visual approaches to note-taking."
+  link: https://verbaltovisual.com/
+  type: course
diff --git a/sites/reviews/src/content/reviews/notion-powered-websites/NotionWebsiteOptions.png b/sites/reviews/src/content/reviews/notion-powered-websites/NotionWebsiteOptions.png
new file mode 100644
index 0000000..e229c84
Binary files /dev/null and b/sites/reviews/src/content/reviews/notion-powered-websites/NotionWebsiteOptions.png differ
diff --git a/sites/reviews/src/content/reviews/notion-powered-websites/Screenshot_2021-09-11_at_10.48.54_AM.png b/sites/reviews/src/content/reviews/notion-powered-websites/Screenshot_2021-09-11_at_10.48.54_AM.png
new file mode 100644
index 0000000..422186a
Binary files /dev/null and b/sites/reviews/src/content/reviews/notion-powered-websites/Screenshot_2021-09-11_at_10.48.54_AM.png differ
diff --git a/sites/reviews/src/content/reviews/notion-powered-websites/Screenshot_2021-09-11_at_10.49.30_AM.png b/sites/reviews/src/content/reviews/notion-powered-websites/Screenshot_2021-09-11_at_10.49.30_AM.png
new file mode 100644
index 0000000..97a847b
Binary files /dev/null and b/sites/reviews/src/content/reviews/notion-powered-websites/Screenshot_2021-09-11_at_10.49.30_AM.png differ
diff --git a/sites/reviews/src/content/reviews/notion-powered-websites/Screenshot_2021-09-11_at_2.55.59_AM.png b/sites/reviews/src/content/reviews/notion-powered-websites/Screenshot_2021-09-11_at_2.55.59_AM.png
new file mode 100644
index 0000000..331bf1e
Binary files /dev/null and b/sites/reviews/src/content/reviews/notion-powered-websites/Screenshot_2021-09-11_at_2.55.59_AM.png differ
diff --git a/sites/reviews/src/content/reviews/notion-powered-websites/Screenshot_2021-09-11_at_2.57.18_AM.png b/sites/reviews/src/content/reviews/notion-powered-websites/Screenshot_2021-09-11_at_2.57.18_AM.png
new file mode 100644
index 0000000..966ca53
Binary files /dev/null and b/sites/reviews/src/content/reviews/notion-powered-websites/Screenshot_2021-09-11_at_2.57.18_AM.png differ
diff --git a/sites/reviews/src/content/reviews/notion-powered-websites/Screenshot_2021-09-11_at_3.09.44_AM.png b/sites/reviews/src/content/reviews/notion-powered-websites/Screenshot_2021-09-11_at_3.09.44_AM.png
new file mode 100644
index 0000000..ab3d2b9
Binary files /dev/null and b/sites/reviews/src/content/reviews/notion-powered-websites/Screenshot_2021-09-11_at_3.09.44_AM.png differ
diff --git a/sites/reviews/src/content/reviews/notion-powered-websites/Screenshot_2021-09-11_at_3.11.05_AM.png b/sites/reviews/src/content/reviews/notion-powered-websites/Screenshot_2021-09-11_at_3.11.05_AM.png
new file mode 100644
index 0000000..81ada4b
Binary files /dev/null and b/sites/reviews/src/content/reviews/notion-powered-websites/Screenshot_2021-09-11_at_3.11.05_AM.png differ
diff --git a/sites/reviews/src/content/reviews/notion-powered-websites/Screenshot_2021-09-11_at_3.47.15_AM.png b/sites/reviews/src/content/reviews/notion-powered-websites/Screenshot_2021-09-11_at_3.47.15_AM.png
new file mode 100644
index 0000000..fe3aa0a
Binary files /dev/null and b/sites/reviews/src/content/reviews/notion-powered-websites/Screenshot_2021-09-11_at_3.47.15_AM.png differ
diff --git a/sites/reviews/src/content/reviews/notion-powered-websites/Screenshot_2021-09-11_at_4.09.58_AM.png b/sites/reviews/src/content/reviews/notion-powered-websites/Screenshot_2021-09-11_at_4.09.58_AM.png
new file mode 100644
index 0000000..8c10e2e
Binary files /dev/null and b/sites/reviews/src/content/reviews/notion-powered-websites/Screenshot_2021-09-11_at_4.09.58_AM.png differ
diff --git a/sites/reviews/src/content/reviews/notion-powered-websites/index.md b/sites/reviews/src/content/reviews/notion-powered-websites/index.md
new file mode 100644
index 0000000..469fcf3
--- /dev/null
+++ b/sites/reviews/src/content/reviews/notion-powered-websites/index.md
@@ -0,0 +1,203 @@
+---
+title: "Notion-powered websites"
+description: "Given that I have been spending most of my time in Notion of late, it made sense to wonder if I could use Notion, directly or otherwise, for whenever I have a need to put someth..."
+pubDate: "2021-09-11"
+authorName: "Neeldhara"
+sourceCategories: ["notion", "workflows", "websites"]
+sourcePath: "notion-powered-websites/index.qmd"
+---
+
+Given that I have been spending most of my time in [Notion](https://www.notion.so) of late, it made sense to wonder if I could use Notion, directly or otherwise, for whenever I have a need to put something up on a public website — e.g, course pages, event websites, and the like. It should go without saying that there are now a gazillion ways of putting a website together — ranging from Wordpress to modern frameworks that have made good old static sites cool again (I'm looking at you, [SSGs](https://jamstack.org/generators/) on the [JAMstack](https://jamstack.org)), and a whole bunch of things in between. All of this is *way* out of scope of this discussion, which is really limited to exploring the most reasonable ways of turning your Notion content into a website and is largely in the spirit of a [no-code setup](https://en.wikipedia.org/wiki/No-code_development_platform).
+
+<blockquote class="twitter-tweet"><p lang="en" dir="ltr">It’s almost like there’s something missing between static HTML and full JavaScript software.</p>&mdash; Wes Souza 🏳️‍🌈⬣ (@__WesSouza) <a href="https://twitter.com/__WesSouza/status/1433096081945018381?ref_src=twsrc%5Etfw">September 1, 2021</a></blockquote> 
+<blockquote class="twitter-tweet"><p lang="en" dir="ltr">Yeah, it feels like we are now at a point where it’s easier to make complex websites but somehow oddly harder to make the simple ones!</p>&mdash; Neeldhara (@neeldhara) <a href="https://twitter.com/neeldhara/status/1433098222189248516?ref_src=twsrc%5Etfw">September 1, 2021</a></blockquote> 
+
+<aside>
+💡 Most options here ultimately amount to SSGs in the background, but with varying levels of exposure to what's happening at the low-level.
+</aside>
+
+There are a few different options out there if you are interested in this as well, and here's a handwritten TLDR-summary[^1] if you find the rest of this little discussion too long:
+
+[^1]: TIL that this style of summarization is also called a [Pugh chart](https://en.wikipedia.org/wiki/Decision-matrix_method), thanks to [Justin Lai.](https://www.youtube.com/channel/UC1S5O9BP9_46GS5t1t2Uksg/about)
+
+![Notion Website Options Compared](NotionWebsiteOptions.png)
+
+---
+
+Now for the more detailed run-down:
+
+### Just Use Notion
+
+The official [Notion documentation](https://www.notion.so/guides/build-a-website-with-notion-in-seconds-no-coding-required) shows us how to build nice websites with Notion:
+
+![](Screenshot_2021-09-11_at_2.57.18_AM.png)
+
+This is a great option for putting together something quick and temporary or for testing something out. It can be free (if you are on the Notion free plan) and/or will cost you nothing *on top of* what you might be paying for already if you are paying Notion user.
+
+<blockquote class="twitter-tweet"><p lang="en" dir="ltr">&quot;What&#39;s the link to your site?&quot;<br><br>&quot;Oh it&#39;s acmedesign dot notion dot site slash dd5a6abe47444a53b7170afd67942d77&quot;<br><br>🙅🏾‍♂️🙅🏼🙅🏻‍♀️<br><br>Now for folks with paid plans, you can set a public home page like <a href="https://t.co/tf1bBQcNJy">https://t.co/tf1bBQcNJy</a>! <a href="https://t.co/LFWYQtgloq">pic.twitter.com/LFWYQtgloq</a></p>&mdash; Notion (@NotionHQ) <a href="https://twitter.com/NotionHQ/status/1440402077201494028?ref_src=twsrc%5Etfw">September 21, 2021</a></blockquote> 
+
+<aside>
+💡 If you have a more serious use-case, however, and are concerned about things like performance, SEO, custom domains, and such, and want to exercise more control over the look and feel of your site, you probably want to move beyond what you can get with xyz.notion.site. Still, a great option — involving no extra costs and right out of the box — and I’d imagine this covers a number of use-cases! 👍
+
+</aside>
+
+### Fruition and  Cloudflare Workers
+
+A popular way to get your domain to point to your Notion setup and customize the look and feel of the final setup just a little bit is via Fruition:
+
+![](Screenshot_2021-09-11_at_2.55.59_AM.png)
+
+As mentioned on the website already, one downside is the setup time — but I don't think this is a very serious drawback at all, it's a one-time exercise and not very difficult at all given the very clear instructions given on the website. However, I think there is a more significant concern with this option, which was highlighted by @[bensomething](https://twitter.com/bensomething) in this Tweet thread:
+
+<blockquote class="twitter-tweet"><p lang="en" dir="ltr">Perhaps a good example of why you should avoid custom domain solutions for Notion that use those damn Cloudflare worker scripts. But hey, super excited for my new startup (fartup?) to be featured on the Founded by Monzonauts website! <a href="https://twitter.com/monzo?ref_src=twsrc%5Etfw">@monzo</a> <a href="https://twitter.com/hugocornejo?ref_src=twsrc%5Etfw">@hugocornejo</a> <a href="https://t.co/0FH916uvd2">https://t.co/0FH916uvd2</a></p>&mdash; Ben Smith (@bensomething) <a href="https://twitter.com/bensomething/status/1354040148074377218?ref_src=twsrc%5Etfw">January 26, 2021</a></blockquote> 
+
+
+You could have a (potentially *your*) Fruition site intercepted with random content, [as is the case here](https://fruitionsite.com/d291bca5556e4696b96911fb1f39efde). As Ben points out, it's much safer to convert your Notion content into a static site:
+
+<blockquote class="twitter-tweet"><p lang="en" dir="ltr">Anything that converts your Notion pages to static versions is fine! It definitely seems like Super&#39;s leading the pack, but I&#39;d say a substantial number of people are still using something like Fruition.</p>&mdash; Ben Smith (@bensomething) <a href="https://twitter.com/bensomething/status/1354145612929921025?ref_src=twsrc%5Etfw">January 26, 2021</a></blockquote> 
+
+<aside>
+💡 To summarize what we have with Fruition: it's probably *okay* for a small test setup, and it's a cool experiment — largely free (you might hit up Cloudflare's limits eventually and be prompted to upgrade) and not much work to setup — but I'd be wary of using it in production for any non-trivial project.
+</aside>
+
+...and so we're going to explore a few ways of doing that now.
+
+
+### nextjs-notion-starter-kit and react-notion-x
+
+The `nextjs-notion-starterkit` is a NextJS template built by @[transitive_bs](https://twitter.com/transitive_bs), which is [in active use here](https://transitivebullsh.it):
+
+![](Screenshot_2021-09-11_at_3.11.05_AM.png)
+
+You can check out [the repository here](https://github.com/transitive-bullshit/nextjs-notion-starter-kit). If you are feeling even braver, you might even want to explore what powers this under the hood, which is the `react-notion-x` repository [here](https://github.com/NotionX/react-notion-x):
+
+![](Screenshot_2021-09-11_at_3.09.44_AM.png)
+
+<aside>
+💡 Using `nextjs-notion-starterkit` is definitely a whole lot safer than Fruition, but it's also clearly a whole lot more intensive in terms of setup! This option is great in terms of being free and highly customizable, but is best-suited to those who are already familiar with Next.js and who generally know what they are doing. So if the readme pages on those repositories did not make much sense, it's probably best to either get some help on the initial setup or move on to more user-friendly, truly *no-code* options. That's what we have up next!
+</aside>
+
+`react-notion-x` — from a safe distance as far as I am concerned — appears to be very well-documented and actively maintained. The documentation speaks of hosting on [Vercel](https://vercel.com), and my guess is that hosting on [Netlify](https://www.netlify.com) should also be possible. Both of these options have generous free tiers, so this could potentially be a no-cost option, although it's far from being a true no-code option, at least for the initial setup!
+
+Interestingly, `react-notion-x` appears to be supported by [Super](https://super.so), and from a quick glance at the source code, it seems like both Super and [Potion](https://www.potion.so) (which are the last two options that we'll be getting to) generate static sites using the Next.js framework... chances are that what is in these repositories is suggestive of at least a part of what's going on behind-the-scenes with Super and Potion.
+
+My understanding from exchanges with support at both Super and Potion is that there are differences in the implementation details — there are definitely visible differences that indicate this too, and apparently Super is more closely-knit into the Notion API, but I am not sure what to make of that just yet... it possibly makes their implementation a little less vulnerable to being broken by updates at Notion's end, but I don't know enough to say this for sure.
+
+
+### Super
+
+[Super](https://super.so) (on [ProductHunt](https://www.producthunt.com/blog/super-2-0)), built by @[Traf](https://twitter.com/traf) and @[TrillCyborg](https://twitter.com/TrillCyborg) (Jason Werner) appears to be one of the leading options in terms of a no-code way of porting a Notion page to a website. This will set you back $12/site/month; but you get a substantial feature set in return:
+
+![](Screenshot_2021-09-11_at_3.47.15_AM.png)
+
+I should point out that some Super templates are premium and will cost separately, but there are some really nice free ones that you can run with right away. [One that I really liked](https://hq.super.site) happens to be free and is in use on the [website I have for my courses](https://neeldhara.courses). I had a completely painless setup experience and very responsive support on the minor things that I did get stuck on (h/t: @[camincoll](https://twitter.com/camincoll)).
+
+Sites made with Super are performant, SEO-friendly, and fairly customizable. There are only two minor snags I ran into with Super: one is that updates on Notion take some time to reflect on the website (typically a minute or so — this is no big deal in general, but it's just not real-time, and can feel slow while in testing and development). The other is that their terms of service seem a bit unusually restrictive — for instance, see the discussion initiated by @[kulikalov](https://twitter.com/kulikalov) here:
+
+<blockquote class="twitter-tweet"><p lang="en" dir="ltr">That&#39;s a shaky foundation to work with <a href="https://twitter.com/super_?ref_src=twsrc%5Etfw">@super_</a> 😐 <a href="https://t.co/yYQYuGZk3u">pic.twitter.com/yYQYuGZk3u</a></p>&mdash; Anton Kulikalov 🇺🇦 (@kulikalov) <a href="https://twitter.com/kulikalov/status/1431144115320860672?ref_src=twsrc%5Etfw">August 27, 2021</a></blockquote> 
+
+<aside>
+💡 At $12/site/month Super is the most expensive option on this list, but if the combination of performance and convenience is what you are looking for, you might find that it is totally worth it.
+</aside>
+
+From Super's responses in this conversation, I am optimistic that the ToS will change for the better. From my direct experience, my instinct is that there isn't really anything to worry about here, but if you are someone who cares about the fine print, this is an aspect you might want to be aware of.
+
+
+### Potion
+
+Finally, we have [Potion](https://www.potion.so) (on [ProductHunt](https://www.producthunt.com/blog/potion-2)), made by @[noahwbragg](https://twitter.com/noahwbragg) (Noah Bragg), which is yet another way of getting a static site out of your Notion content in a fairly straightforward way:
+
+![](Screenshot_2021-09-11_at_4.09.58_AM.png)
+
+<aside>
+💡 While oversimplified, it is tempting to summarize Potion's offering as "Super, but cheaper". See the next section for a more detailed discussion of differences and similarities between the two. Overall, Potion has a very similar feature set and is slightly more affordable in comparison — definitely worth checking out the same way that Super is.
+</aside>
+
+The pricing is a bit different from Super — it can cost you as little as $6.25/site/month on their 8-sites plan, which will set you back $50/month, and the other two possibilities are $10/month for one site or $25/month for three.
+
+In terms of what it does, it feels rather similar to Super, but as I mentioned earlier, I think there are differences in the actual implementation. In particular, one difference that is conspicuous is the way Potion renders changes — much like what happens with Notion's own public pages, the rendering of changes with Potion happens practically in real-time. This is very helpful, especially when you are working on quick edits, or are testing things out.
+
+Many other features are at par with Super: the sites created by Potion appear to be equally performant and SEO-friendly; and sites on Potion are customizable in almost the same ways.
+
+This page (and the whole blog) is rendered with Potion. Like Super, setup was largely frictionless and I had prompt help whenever I needed it. Potion also has a bunch of templates that work out of the box — a couple of which are premium — but the vast majority of them are available for free and already there are some fairly nice options.
+
+
+### Potion v/s Super
+
+Given the similarities between Potion and Super, I felt it was worth having a separate discussion comparing the two, and I felt like I could do a brief take on this given that I've spent a fair amount of time trying out both and being conflicted about which one to go with! As you can probably tell if you read this far, I could not positively conclude one way or the other, so my setups are split between the two at the moment, and it'll probably stay this way for a while now 😀
+
+Back to the comparison — there are a few differences on the minor features, here are a couple of examples off the top of my head:
+
+1. Super allows password protection on individual pages, on Potion it's all-or-none (at least at the time of this writing).
+
+2. Potion automatically generates preview images based on titles — this is what shows up when you share a link on, say, Twitter or Discord or WhatsApp. It does this automatically for *all* pages, even ones within databases.
+
+3. I could not get jquery to work in Potion (from trying very briefly), but it worked out fine on Super.
+
+4. Super has a community forum and an arguably restrictive ToS. Potion has neither at the time of this writing.
+
+5. Potion's dashboard has a live preview editor which lets you make simple changes to the CSS and preview them real-time — this may not be something you use often if you have made sophisticated customizations, but for quick edits to the default templates, it's very handy:
+
+
+![](Screenshot_2021-09-11_at_10.49.30_AM.png)
+
+Super has a great dashboard too, there's a page-by-page breakup on the sidebar and a live preview of the site to the right, which shows up even when the individual pages are password-protected (by design):
+
+![](Screenshot_2021-09-11_at_10.48.54_AM.png)
+
+6. In terms of custom code, a small difference is that Super allows you to insert your own content inside *both* the `<head>` and `<body>` tags while Potion is restricted to just the `<head>` tag. That said, additional possibilities for custom code injection are on Potion's roadmap.
+
+7. There are differences of implementation under the hood, but I am not aware of the exact details here. Super uses the Notion API and a Content Delivery Network (CDN) - this explains why changes take 1-2 mins to flow through from Notion in Super automatically, but what it does get you is reliable performance at scale. Potion uses Vercel for hosting and generates static sites that feel fast and robust, and also uses a CDN.
+
+Here are some of the things that I think work out rather similarly on both platforms:
+
+1. Accessible and very friendly support 🤩
+
+2. Convenient to setup and use.
+
+3. SEO, pretty URLs, custom domains, pretty-URLs, and mostly performant websites.
+
+4. Customized output thanks to the ability to insert your own scripts and CSS.
+
+5. Promising roadmaps on both with exciting features on the way 🎉
+
+6. Both options seem generally reliable - I have been monitoring my websites using [Fathom](https://usefathom.com) and I've had a few downtimes reported here and there from both platforms. There was nothing that lasted more than a few minutes at a time. Because both Super and Potion use a CDN, it turns out that even if these services go down, hopefully the sites will still be served as usual.
+
+7. You will find that both have great feedback on ProductHunt (and possibly other platforms too, but PH is the one I'm familiar with).
+
+
+### Should you use Notion for your website at all?
+
+Well. In general, if future-proofness is crazy important to you, and you want complete control over how your website renders down to the last pixel — then you might want to consider looking beyond Notion.
+
+> **Note**
+> 
+> 
+> Indeed, these are early days, in some sense *even* for Notion, and much more so for all the options listed here. A few ways of turning Notion content into websites have come-and-gone, and that, I think, is in the nature of this kind of a setup.
+> 
+> At the moment, all options here other than the native Notion setup will have some obligation to keeping up with changes from the Notion side. I think most options are doing great on this front — as a recent example that comes to mind, globally synced blocks were supported shortly on all platforms after release (you do have to make sure that the pages on which such blocks originate have public access permissions).
+> 
+> I am definitely keeping my fingers crossed for the long-term viability of these options 🤞 Until then, I'm looking forward to enjoying the convenience of being able to work on my website(s) without getting out of Notion at all, at least hopefully not very much 😎
+> 
+> Incidentally, Notion's markdown export is pretty good too, so you could just keep markdown versions of your work as you go along, so in case you decide to port things over into a more direct SSG setup in the future, it would be relatively painless to do.
+
+
+Assuming you are all-in on using Notion for delivering your website, then here's a summary of your options:
+
+1. If you are looking for a free setup:
+
+    1. If need to use custom domains, and need sites that look and behave like regular websites, then you might want to check out `react-notion-x` or `nextjs-notion-starterkit` if you are an expert, but otherwise, the Notion route may not be the best for you.
+
+    2. If you are already a Notion user and you just need a URL with content that can go around for a super-specific purpose (i.e, website-y features not so crucial) — you can likely just use Notion's default facility with a public URL.
+
+2. If you have a budget that is compatible with Super and/or Potion, I would definitely recommend either of them - they are both great solutions in this context! There are some nuances in terms of how they are different (e.g, pricing; Super's apparently deeper integration with the Notion API v/s Potion's real-time implementation, etc.), and if that level of detail is important to you, you might need to try out both — which is fortunately easy to do — before deciding.
+
+### Other ways of getting a website out of Notion?
+
+There are a few options that I didn't cover here, including, for example, [Notion2Blog](https://mynotion.blog), [Notion Dog](https://github.com/notiondog/notion.dog), [Notelet](https://notelet.so), [~~Nocodepages~~](https://nocodepages.com) (now defunct), and a couple of others that I did evaluate — at least briefly — but I unfortunately can't remember any more. If you know of other examples, please let me know and I'll be happy to append them to this list here!
+
+---
+
+<aside>
+💡 Please share your comments on Twitter @[neeldhara](https://twitter.com/neeldhara). Also, special thanks to @[camincoll](https://twitter.com/camincoll) and @[noahwbragg](https://twitter.com/noahwbragg) for their inputs and help with Super and Potion, respectively! 👋🏽
+</aside>
diff --git a/sites/reviews/src/content/reviews/obsidian-review.md b/sites/reviews/src/content/reviews/obsidian-review.md
deleted file mode 100644
index 599013f..0000000
--- a/sites/reviews/src/content/reviews/obsidian-review.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: "Obsidian: A Year Later"
-description: "Reflections on using Obsidian for research notes, teaching materials, and personal knowledge management."
-pubDate: "Jan 15 2024"
-image: "https://images.unsplash.com/photo-1484480974693-6ca0a78fb36b?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Obsidian: A Year Later
-
-After a year of daily use, Obsidian has transformed how I think about knowledge management.
-
-## What Works Brilliantly
-
-### The Graph View
-Seeing connections between ideas visually has led to unexpected research insights. The graph isn't just pretty - it's functional.
-
-### Plugin Ecosystem
-The community plugins are incredible. Dataview turns your notes into a database. Templater automates repetitive tasks.
-
-### Local Storage
-Your notes are just markdown files. No vendor lock-in, complete control, and peace of mind.
-
-## Pain Points
-
-### Mobile Experience
-While functional, the mobile app lacks the fluidity of the desktop version. Syncing can occasionally hiccup.
-
-### Learning Curve
-The flexibility means complexity. New users might feel overwhelmed by options.
-
-## The Verdict
-
-For academics and researchers, Obsidian is transformative. The investment in learning pays dividends in productivity and insight.
diff --git a/sites/reviews/src/content/reviews/pandoc-letters/index.md b/sites/reviews/src/content/reviews/pandoc-letters/index.md
new file mode 100644
index 0000000..e1f6545
--- /dev/null
+++ b/sites/reviews/src/content/reviews/pandoc-letters/index.md
@@ -0,0 +1,69 @@
+---
+title: "Letters with Pandoc"
+description: "Letter-writing season is around the corner. I recently adapted this pandoc workflow for generating PDF letters by only editing a markdown file. I only made the following minor c..."
+pubDate: "2022-11-27"
+authorName: "Neeldhara"
+sourceCategories: ["pandoc", "workflows", "latex"]
+sourcePath: "pandoc-letters/index.qmd"
+---
+
+Letter-writing season is around the corner. I recently adapted [this pandoc workflow](https://github.com/yangjiandong/myPandoc/tree/faf94dc26487005b03baa7a2d807b20b2a7f233f/demo/letter) for generating PDF letters by only editing a markdown file. I only made the following minor changes to the original:
+
+<aside>
+For this to work you will need [pandoc](https://pandoc.org) and a TeX distribution installed. For a full-fledged TeX distribution check out something like [MacTeX](https://www.tug.org/mactex/) and for a minimal variation, see [TinyTeX](https://yihui.org/tinytex/).
+</aside>
+
+1. Included the `fontawesome5` package so I could add icons alongside the phone number, email, and website in the letterhead.
+
+2. Changed `ThisULCornerWallPaper` to `CenterWallPaper` and added `wpYoffset` and `wpXoffset` so I could get a left margin on the logo (I suppose this _could_ also be done by offsetting the logo in the `letterhead.pdf` file).
+
+Here's what the output looks like with some random sample content:
+
+![Sample letter produced with the pandoc workflow](output.png)
+
+The markdown is very simple to edit --- most of the information is up in the YAML header, and it looks like this:
+
+```yaml
+author: Fyodor Michailovitch Dostoevsky
+city: Moscow
+from:
+- By the Vladimirkirche
+- care of Pryanischnikof, Grafengasse.
+affiliation1: Add an affiliation
+affiliation2: Potential Additional Information
+contact:
+- \faPhone \ +91 79 1234 1729
+- \faGlobe \ https://www.google.com
+- \faEnvelope \ nobody@nowhere.com
+to:
+- Michael
+- Someplace
+- with an address
+subject: An Update
+salutation: My dearest
+toname: brother
+customdate: 1838-8-9
+```
+
+Write the body of the letter in markdown as usual, and generate the PDF by running:
+
+```
+pandoc letter.md -o output.pdf --template=template.tex --pdf-engine=xelatex
+```
+
+or have a makefile that looks like this:
+
+```
+TEX = pandoc
+FLAGS = --pdf-engine=xelatex
+
+src1 = template.tex letter.txt
+op1 = output
+
+all : $(op1).pdf
+
+$(op1).pdf : $(src1)
+	$(TEX) $(filter-out $<,$^ ) -o $@ --template=$< $(FLAGS)
+```
+
+For your first use, you would want to update the images for the letterhead and the signature, and optionally customize the fonts to your liking. [Fork this repo](https://github.com/neeldhara/pandoc-letters) to make your own!
diff --git a/sites/reviews/src/content/reviews/pandoc-letters/output.png b/sites/reviews/src/content/reviews/pandoc-letters/output.png
new file mode 100644
index 0000000..5c2c341
Binary files /dev/null and b/sites/reviews/src/content/reviews/pandoc-letters/output.png differ
diff --git a/sites/reviews/src/content/reviews/women-in-mathematics/index.md b/sites/reviews/src/content/reviews/women-in-mathematics/index.md
new file mode 100644
index 0000000..243f4c7
--- /dev/null
+++ b/sites/reviews/src/content/reviews/women-in-mathematics/index.md
@@ -0,0 +1,90 @@
+---
+title: "Women in Mathematics"
+description: "Here’s a list of books — in no particular order — about women in mathematics (broadly interpreted) largely taken from this thread. The links are mostly to versions of the books..."
+pubDate: "2022-02-21"
+authorName: "Neeldhara"
+sourceCategories: ["books", "lists"]
+sourcePath: "women-in-mathematics/index.qmd"
+---
+
+Here’s a list of books — in no particular order — about women in mathematics (broadly interpreted) largely taken from [this thread](https://twitter.com/stevenstrogatz/status/1495030448904458243). The links are mostly to versions of the books on Amazon India. Unfortunately many of them are rather expensive, but hopefully it’s a handy list to share with a librarian you know! Do leave a comment below if you have any additions.
+
+I’ll also leave this [relatively sobering thought](https://twitter.com/virtualcourtney/status/1495076053257175040) (or [this one](https://twitter.com/MarissaKawehi/status/1495083281766879243?s=20&t=9CWcnFgcqBQZD4p01UFXsg)) here with no further comment.
+
+---
+
+Books:
+
+1. [Complexities – Women in Mathematics](https://www.amazon.in/Complexities-Mathematics-Bettye-Anne-Case/dp/0691114625/)
+
+2. [Women in Mathematics – The Addition of Difference](https://www.amazon.in/Women-Mathematics-Addition-Difference-Science/dp/0253211190/ref=sr_1_1?crid=XLR5PKP93HN1&keywords=Women+in+Mathematics%3A+The+Addition+of+Difference&qid=1645384438&sprefix=women+in+mathematics+the+addition+of+difference%2Caps%2C277&sr=8-1)
+
+3. [How to Free Your Inner Mathematician: Notes on Mathematics and Life](https://www.amazon.in/How-Free-Your-Inner-Mathematician/dp/0198843593/)
+
+4. [Ada's Algorithm: How Lord Byron's Daughter Launched the Digital Age Through the Poetry of Numbers](https://www.amazon.in/Adas-Algorithm-Daughter-Launched-Digital/dp/1783340711/)
+
+5. [Women Who Count: Honoring African American Women Mathematicians](https://www.amazon.in/Women-Who-Count-Honoring-Mathematicians/dp/1470448890/)
+
+6. [Women Becoming Mathematicians – Creating a Professional Identity in Post–World War II America](https://www.amazon.in/Women-Becoming-Mathematicians-Professional-Post-World/dp/0262632462/)
+
+7. [Power in Numbers: The Rebel Women of Mathematics](https://www.amazon.in/Power-Numbers-Rebel-Women-Mathematics/dp/1631064851/)
+
+8. [My Remarkable Journey: A Memoir](https://www.amazon.in/My-Remarkable-Journey-Katherine-Johnson/dp/0062897667/) (Katherine Johnson)
+
+9. [Proving It Her Way: Emmy Noether, a Life in Mathematics](https://www.amazon.in/Proving-Her-Way-Noether-Mathematics/dp/3030628108/)
+
+10. [Emmy Noether’s Wonderful Theorem](https://www.amazon.in/Emmy-Noether%60s-Wonderful-Theorem-2e/dp/1421422670/)
+
+11. [Love and Mathematics: Sofya Kovalevskaya](https://www.amazon.in/Love-Mathematics-Kovalevskaya-P-Kochina/dp/0828533733/) ([alternate link](https://archive.org/details/kochinaloveandmathematicssofyakovalevskaya1985/mode/2up))
+
+12. [Einstein's Wife: The Real Story of Mileva Einstein-Maric](https://www.amazon.in/Einsteins-Wife-Story-Mileva-Einstein-Maric/dp/1665124997)
+
+13. [Inventing the Mathematician: Gender, Race, and Our Cultural Understanding of Mathematics](https://www.amazon.in/Inventing-Mathematician-Cultural-Understanding-Mathematics-ebook/dp/B01CPUKOR6/)
+
+14. [In Code: A Mathematical Journey](https://www.amazon.in/Code-Mathematical-Journey-David-Flannery/dp/1861972717)
+
+15. [Against All Odds: Women’s Ways to Mathematical Research Since 1800: 6 (Women in the History of Philosophy and Sciences)](https://www.amazon.in/Against-All-Odds-Mathematical-Philosophy/dp/303047612X)
+
+16. [The Ascent of Mary Somerville in 19th Century Society](https://www.amazon.in/Somerville-Century-Society-Springer-Biographies-ebook/dp/B01N1M5D2H/)
+
+17. [Julia: A Life in Mathematics](https://bookstore.ams.org/spec-18/) (ebook only)
+
+18. [Women of Mathematics: A Bio-Bibliographic Sourcebook](https://www.amazon.in/Women-Mathematics-Bio-Bibliographic-Sourcebook-Bibliographic-ebook/dp/B000WBBEIE/)
+
+19. [A Celebration of the EDGE Program's Impact on the Mathematics Community and Beyond](https://www.amazon.in/Celebration-Programs-Impact-Mathematics-Community/dp/3030194884/)
+
+20. [Those Magnificent Women and their Flying Machines: ISRO'S Mission to Mars](https://www.amazon.in/Those-Magnificent-Women-Flying-Machines/dp/9388874587)
+
+21. [Girls Coming to Tech!: A History of American Engineering Education for Women](https://www.amazon.in/Girls-Coming-Tech-Engineering-Education-ebook/dp/B08BTB9HQ2/)
+
+22. [Fifty Years of Women in Mathematics](https://link.springer.com/book/9783030826574)
+
+23. [x+y: A Mathematician's Manifesto for Rethinking Gender](https://www.amazon.in/Mathematicians-Manifesto-Rethinking-Gender/dp/178816041X/)
+
+
+Illustrated Books:
+
+1. [Maryam’s Magic: The Story of Mathematician Maryam Mirzakhani](https://www.amazon.in/Maryams-Magic-Mathematician-Maryam-Mirzakhani/dp/0062915967/)
+
+2. [Nothing Stopped Sophie: The Story of Unshakable Mathematician Sophie Germain](https://www.amazon.in/Nothing-Stopped-Sophie-Cheryl-Bardoe/dp/0316278203/)
+
+3. [Grace Hopper: Queen of Computer Code](https://www.amazon.in/Grace-Hopper-Queen-Computer-Changed/dp/1454920009/)
+
+4. [Ada Byron Lovelace and the Thinking Machine](https://www.amazon.in/Ada-Byron-Lovelace-Thinking-Machine/dp/1939547202)
+
+5. [The Thrilling Adventures of Lovelace and Babbage: The (Mostly) True Story of the First Computer](https://www.amazon.in/Thrilling-Adventures-Lovelace-Babbage-Computer/dp/0141981539/)
+
+6. [The Girl With a Mind for Math: The Story of Raye Montague](https://www.amazon.in/Girl-Mind-Math-Montague-Scientists/dp/1943147426/)
+
+7. [Hidden Figures: The True Story of Four Black Women and the Space Race](https://www.amazon.in/Hidden-Figures-Story-Black-Women/dp/0062742469/)
+
+8. [Counting on Katherine: How Katherine Johnson Put Astronauts on the Moon](https://www.amazon.in/Counting-Katherine-Johnson-Astronauts-Moon/dp/1529005612/)
+
+9. [Emmy Noether: The Most Important Mathematician You've Never Heard Of](https://www.amazon.in/Emmy-Noether-Important-Mathematician-Youve-ebook/dp/B08J87C17B)
+
+
+Miscellaneous:
+
+1. [A Tribute to Professor Helena Rasiowa](http://comet.lehman.cuny.edu/fitting/bookspapers/pdf/papers/Rasiowa.pdf) (PDF)
+
+2. [A Groundbreaking Mathematician on the Gender Politics of Her Field](https://www.newyorker.com/news/q-and-a/groundbreaking-mathematician-karen-uhlenbeck-on-the-politics-of-her-field/amp) (New Yorker)
diff --git a/sites/reviews/src/content/vibes/creative-coding-with-ai.md b/sites/reviews/src/content/vibes/creative-coding-with-ai.md
deleted file mode 100644
index 269f1ce..0000000
--- a/sites/reviews/src/content/vibes/creative-coding-with-ai.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "Creating Art with Claude: A Collaborative Journey"
-description: "Exploring creative possibilities through conversations with AI - from generative art to interactive poetry."
-pubDate: "Jan 18 2024"
-image: "https://images.unsplash.com/photo-1558591710-4b4a1ae0f04d?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Creating Art with Claude: A Collaborative Journey
-
-What happens when you treat AI as a creative collaborator rather than just a tool?
-
-## The Experiment
-
-I asked Claude to help design a generative art algorithm based on mathematical fractals. The conversation evolved into something unexpected.
-
-## The Process
-
-**Me**: "Let's create something beautiful with math."
-**Claude**: "How about we visualize the Collatz conjecture as a tree?"
-
-What followed was a two-hour deep dive into number theory, aesthetics, and the nature of creativity itself.
-
-## The Result
-
-Not just code, but a philosophical exploration of pattern, meaning, and the intersection of human and artificial creativity.
-
-## Reflection
-
-AI doesn't replace human creativity - it amplifies it in unexpected directions. The key is approaching it as a dialogue, not a command.
diff --git a/sites/reviews/src/content/vibes/llm-philosophy.md b/sites/reviews/src/content/vibes/llm-philosophy.md
deleted file mode 100644
index 032439a..0000000
--- a/sites/reviews/src/content/vibes/llm-philosophy.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-title: "Philosophical Dialogues with LLMs: On Consciousness and Computation"
-description: "Deep conversations with AI about the nature of consciousness, free will, and what it means to understand."
-pubDate: "Feb 28 2024"
-image: "https://images.unsplash.com/photo-1507003211169-0a1dd7228f2d?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Philosophical Dialogues with LLMs: On Consciousness and Computation
-
-Can a sufficiently complex computation be conscious? I asked an AI, and the conversation surprised me.
-
-## The Question
-
-"Do you experience anything when you process text, or is it just computation?"
-
-## The Response That Made Me Think
-
-The AI didn't claim consciousness, but asked: "What's the difference between your neurons firing and my weights activating? Both are physical processes. Where does experience emerge?"
-
-## Going Deeper
-
-We explored qualia, the Chinese Room argument, and integrated information theory. Not to find answers, but to refine questions.
-
-## The Irony
-
-Discussing consciousness with something that might not have it - or might not know if it has it - mirrors our own uncertainty about consciousness itself.
diff --git a/sites/reviews/src/pages/[...slug].astro b/sites/reviews/src/pages/[...slug].astro
index 5d3caf6..ea2f2d7 100644
--- a/sites/reviews/src/pages/[...slug].astro
+++ b/sites/reviews/src/pages/[...slug].astro
@@ -9,7 +9,7 @@ import { SITE_TITLE } from '@/consts';
 export async function getStaticPaths() {
 	const posts = await getCollection(ACTIVE_BLOG_SITE.key);
 	return posts.map((post) => ({
-		params: { slug: post.id },
+		params: { slug: post.id.replace(/\/index$/, '') },
 		props: post,
 	}));
 }
diff --git a/sites/reviews/src/pages/rss.xml.js b/sites/reviews/src/pages/rss.xml.js
index ec2ce2d..918375e 100644
--- a/sites/reviews/src/pages/rss.xml.js
+++ b/sites/reviews/src/pages/rss.xml.js
@@ -14,7 +14,7 @@ export async function GET(context) {
     site: context.site,
     items: posts.map((post) => ({
       ...post.data,
-      link: `/${post.id}/`,
+      link: `/${post.id.replace(/\/index$/, "")}/`,
     })),
   });
 }
diff --git a/sites/vibes/src/components/sections/blog-posts.tsx b/sites/vibes/src/components/sections/blog-posts.tsx
index fef77e5..c77c76a 100644
--- a/sites/vibes/src/components/sections/blog-posts.tsx
+++ b/sites/vibes/src/components/sections/blog-posts.tsx
@@ -16,8 +16,47 @@ const BlogPosts = ({
   // Get the first post as the featured post
   const featuredPost = posts[0];
   const remainingPosts = posts.slice(1);
+  const slugFor = (post: any) => post.id.replace(/\/index$/, "");
   const hrefFor = (post: any) =>
-    collection ? `/${collection}/${post.id}/` : `/${post.id}/`;
+    collection ? `/${collection}/${slugFor(post)}/` : `/${slugFor(post)}/`;
+
+  const PostVisual = ({
+    post,
+    featured = false,
+  }: {
+    post: any;
+    featured?: boolean;
+  }) => {
+    if (post.data.image) {
+      return (
+        <img
+          src={post.data.image}
+          alt={post.data.title}
+          className="aspect-video w-full rounded-lg object-cover transition-transform group-hover:scale-[1.02]"
+        />
+      );
+    }
+
+    return (
+      <div className="bg-accent/70 text-accent-foreground flex aspect-video w-full items-center justify-center rounded-lg border px-6 text-center">
+        <span
+          className={
+            featured ? "font-fraunces text-2xl" : "font-fraunces text-lg"
+          }
+        >
+          {post.data.title}
+        </span>
+      </div>
+    );
+  };
+
+  if (!featuredPost) {
+    return (
+      <div className="text-muted-foreground container max-w-3xl py-16">
+        No posts yet.
+      </div>
+    );
+  }
 
   return (
     <div className="relative py-10 md:py-16 lg:py-20">
@@ -35,11 +74,7 @@ const BlogPosts = ({
             <div className="flex flex-col gap-6 lg:flex-row">
               <div className="lg:w-1/2">
                 <div className="p-2 lg:p-4">
-                  <img
-                    src={featuredPost.data.image}
-                    alt={featuredPost.data.title}
-                    className="aspect-video w-full rounded-lg object-cover transition-transform group-hover:scale-[1.02]"
-                  />
+                  <PostVisual post={featuredPost} featured />
                 </div>
               </div>
               <div className="flex flex-col justify-center p-4 pb-8 lg:w-1/2 lg:pr-8">
@@ -89,11 +124,7 @@ const BlogPosts = ({
                 href={hrefFor(post)}
               >
                 <div className="p-2">
-                  <img
-                    src={post.data.image}
-                    alt={post.data.title}
-                    className="aspect-video w-full rounded-lg object-cover transition-transform group-hover:scale-[1.01]"
-                  />
+                  <PostVisual post={post} />
                 </div>
                 <div className="px-4 pb-5 pt-2">
                   <h2 className="mb-2 text-xl font-semibold group-hover:underline">
diff --git a/sites/vibes/src/content/art/algorithmic-sketches.md b/sites/vibes/src/content/art/algorithmic-sketches.md
deleted file mode 100644
index ae20d3b..0000000
--- a/sites/vibes/src/content/art/algorithmic-sketches.md
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title: "Algorithmic Sketches: Visualizing Data Structures"
-description: "Hand-drawn illustrations of algorithms and data structures - making the abstract tangible."
-pubDate: "Jan 25 2024"
-image: "https://images.unsplash.com/photo-1581337204873-ef36aa186caa?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Algorithmic Sketches: Visualizing Data Structures
-
-Sometimes the best way to understand an algorithm is to draw it.
-
-## Today's Sketch: Red-Black Trees
-
-![Red-Black Tree Rotation](sketch-placeholder)
-
-The rotation operation finally clicked when I drew it step-by-step. Each node's journey through the rotation becomes a story.
-
-## The Process
-
-1. Start with pencil - mistakes are part of learning
-2. Trace the algorithm's execution
-3. Add color to highlight invariants
-4. Annotate with key insights
-
-## Why Drawing Helps
-
-- Forces you to slow down and really see the structure
-- Reveals patterns that code obscures
-- Creates memorable mental models
-- Makes teaching more engaging
-
-## This Week's Challenge
-
-Draw your own version of quicksort partitioning. Share it and let's learn from each other's visualizations.
-
-## The Art in Computer Science
-
-Algorithms are beautiful. Drawing them reminds us that computer science is as much art as it is science.
diff --git a/sites/vibes/src/content/art/generative-art-p5js.md b/sites/vibes/src/content/art/generative-art-p5js.md
deleted file mode 100644
index ccfa3e7..0000000
--- a/sites/vibes/src/content/art/generative-art-p5js.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "Generative Art with p5.js: Creating Beauty from Mathematics"
-description: "Exploring the intersection of code and creativity through generative art experiments."
-pubDate: "Feb 18 2024"
-image: "https://images.unsplash.com/photo-1561070791-2526d30994b5?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Generative Art with p5.js: Creating Beauty from Mathematics
-
-Code becomes canvas when mathematics meets creativity.
-
-## Today's Creation: Perlin Noise Flows
-
-```javascript
-for (let particle of particles) {
-  let angle = noise(particle.x * 0.01, particle.y * 0.01, frameCount * 0.001) * TWO_PI;
-  particle.velocity = p5.Vector.fromAngle(angle);
-  particle.update();
-  particle.draw();
-}
-```
-
-## The Magic of Randomness
-
-Controlled randomness creates organic patterns. Perlin noise gives us randomness with continuity - nature's own algorithm.
-
-## Parameters as Paintbrushes
-
-- Noise scale: Changes pattern density
-- Particle count: Affects texture
-- Color mapping: Sets the mood
-
-## The Joy of Accidents
-
-The best discoveries come from "mistakes" - a typo that creates unexpected beauty, a parameter pushed to extremes.
-
-## Share Your Creations
-
-Art is meant to be shared. Post your generative experiments and let's inspire each other.
diff --git a/sites/vibes/src/content/poetry/algorithms-in-verse.md b/sites/vibes/src/content/poetry/algorithms-in-verse.md
deleted file mode 100644
index 4ad1e1d..0000000
--- a/sites/vibes/src/content/poetry/algorithms-in-verse.md
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title: "Algorithms in Verse: Bubble Sort Sonnet"
-description: "Classic algorithms reimagined as poetry - where code meets iambic pentameter."
-pubDate: "Feb 22 2024"
-image: "https://images.unsplash.com/photo-1455390582262-044cdead277a?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Algorithms in Verse: Bubble Sort Sonnet
-
-## Bubble Sort: A Sonnet
-
-```
-Compare adjacent elements in pairs,
-If order's wrong, then swap them into place.
-Through all the list this simple rule declares:
-The largest bubbles up to find its space.
-
-Again we start, but now one less to check,
-The second largest finds its rightful home.
-Each pass through makes the chaos less a wreck,
-Until at last no elements must roam.
-
-Though simple in its elegance and grace,
-And easy for beginners to perceive,
-In practice, it's too slow to win the race—
-O(n²) we sadly must believe.
-
-But beauty lies in simplicity's pure art,
-The bubble sort still teaches at the start.
-```
-
-## The Challenge
-
-Can you write Quicksort as a limerick? Or Binary Search as free verse?
-
-## Why This Matters
-
-Poetry forces us to find the essence of an algorithm. The constraint reveals understanding.
diff --git a/sites/vibes/src/content/poetry/code-haikus.md b/sites/vibes/src/content/poetry/code-haikus.md
deleted file mode 100644
index 6af408a..0000000
--- a/sites/vibes/src/content/poetry/code-haikus.md
+++ /dev/null
@@ -1,56 +0,0 @@
----
-title: "Code Haikus: Programming in 5-7-5"
-description: "Expressing programming concepts through the constrained beauty of haiku."
-pubDate: "Jan 30 2024"
-image: "https://images.unsplash.com/photo-1481627834876-b7833e8f5570?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Code Haikus: Programming in 5-7-5
-
-The constraint of haiku forces clarity. Here are programming concepts distilled to their essence.
-
-## On Recursion
-
-```
-Function calls itself
-Smaller problems, same pattern  
-Base case stops the loop
-```
-
-## On Debugging
-
-```
-Print statements bloom wild
-Binary search through the code
-Bug reveals itself
-```
-
-## On Optimization
-
-```
-O(n squared) crawls
-Refactor to n log n
-Time complexity
-```
-
-## On Git Merge Conflicts
-
-```
-<<<<<<< HEAD
-Your changes, their changes clash
-Resolution waits
-```
-
-## On Learning
-
-```
-Stack Overflow searched
-Tutorial incomplete
-Understanding dawns
-```
-
-## Your Turn
-
-Write a haiku about your coding experience today. The constraint reveals truth.
diff --git a/sites/vibes/src/content/puzzles/100-prisoners.mdx b/sites/vibes/src/content/puzzles/100-prisoners.mdx
deleted file mode 100644
index 3ff2b3c..0000000
--- a/sites/vibes/src/content/puzzles/100-prisoners.mdx
+++ /dev/null
@@ -1,183 +0,0 @@
----
-title: "The 100 Prisoners Problem: A Beautiful Puzzle in Probability"
-description: "An interactive exploration of one of the most counterintuitive puzzles in probability theory, where 100 prisoners can escape with over 30% chance using a clever strategy."
-pubDate: "Oct 13 2025"
-image: "https://images.unsplash.com/photo-1589829545856-d10d557cf95f?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-import PrisonerGameSimulator from '@/components/problems/PrisonerGameSimulator.tsx';
-import ProbabilityChart from '@/components/problems/ProbabilityChart.tsx';
-import PermutationExplorer from '@/components/problems/PermutationExplorer.tsx';
-import StrategyComparison from '@/components/problems/StrategyComparison.tsx';
-
-# The 100 Prisoners Problem
-
-Imagine 100 prisoners, numbered 1 to 100, face an unusual challenge. In a room are 100 boxes, also numbered 1 to 100. Inside each box is a randomly assigned number from 1 to 100 (each number appearing exactly once). The prisoners must find their own number by opening boxes, but here's the catch: **each prisoner can open only 50 boxes**.
-
-The prisoners can devise a strategy beforehand, but once the challenge begins, they cannot communicate. If **all 100 prisoners** find their number, everyone goes free. If even one prisoner fails, all remain imprisoned.
-
-What's the best strategy? And what are the odds of success?
-
-## Try It Yourself!
-
-Before we dive into the mathematics, let's experience the problem firsthand. Below is a simulator where you can play the game yourself. Choose the number of prisoners (between 5 and 100), and then try to help each prisoner find their number by clicking on boxes.
-
-<PrisonerGameSimulator client:only="react" />
-
----
-
-## The Naive Strategy
-
-The most obvious approach is for each prisoner to simply open 50 random boxes. This seems reasonable, but the probability of success is dismal.
-
-For any single prisoner, the probability of finding their number in 50 random boxes out of 100 is exactly 1/2. Since all 100 prisoners must succeed, and their outcomes are independent under random selection, the probability that everyone succeeds is:
-
-$$P(\text\{success\}) = \left(\frac\{1\}\{2\}\right)^\{100\} \approx 7.9 \times 10^\{-31\}$$
-
-That's essentially zero! You're more likely to win the lottery while being struck by lightning... multiple times.
-
-### Naive Strategy: Probability vs Number of Prisoners
-
-Watch how the probability of success plummets as we increase the number of prisoners:
-
-<ProbabilityChart strategy="naive" client:only="react" />
-
-As you can see, even with just 10 prisoners, the probability drops to about 0.1%. With 100 prisoners, it's practically impossible.
-
----
-
-## The Clever Strategy: Following the Loops
-
-Here's where mathematics reveals something beautiful. Instead of opening random boxes, each prisoner should follow a simple rule:
-
-1. **Start by opening the box with your own number**
-2. **Look at the number inside that box**
-3. **Open the box with that number next**
-4. **Continue following this chain**
-
-Why does this work? The key insight involves understanding permutations and cycles.
-
-### Understanding Cycles in Permutations
-
-When we randomly assign 100 numbers to 100 boxes, we're creating a **permutation** of the numbers 1 through 100. Every permutation can be decomposed into **cycles**.
-
-For example, if:
-- Box 1 contains number 4
-- Box 4 contains number 7
-- Box 7 contains number 1
-
-Then we have a cycle: 1 -> 4 -> 7 -> 1
-
-Let's explore this with smaller numbers:
-
-<PermutationExplorer client:only="react" />
-
-The interactive explorer above lets you:
-- Generate all permutations for small values of *n* (3, 4, or 5)
-- See both standard notation and cycle notation
-- Filter permutations that have at least one "long cycle" (longer than *n*/2)
-- Understand why long cycles matter
-
-### Why This Strategy Works
-
-Here's the crucial insight: **A prisoner succeeds if and only if they are in a cycle of length ≤ 50**.
-
-When prisoner k follows the loop strategy:
-1. They start at box k
-2. They follow a path through boxes determined by the permutation
-3. This path forms a cycle that eventually leads back to box k
-4. If this cycle has length ≤ 50, they'll find their number within 50 opens
-
-The prisoners **all succeed** if and only if there is **no cycle longer than 50** in the permutation.
-
-### Calculating the Probability
-
-The probability that a random permutation of 100 elements has no cycle longer than 50 is:
-
-$$P(\text\{success\}) = 1 - \sum_\{k=51\}^\{100\} \frac\{1\}\{k\}$$
-
-Computing this sum:
-
-$$P(\text\{success\}) = 1 - \left(\frac\{1\}\{51\} + \frac\{1\}\{52\} + \cdots + \frac\{1\}\{100\}\right) \approx 0.3118$$
-
-That's over **31%**! This is astronomically better than the naive strategy's probability of essentially zero.
-
-### Loop Strategy: Probability vs Number of Prisoners
-
-<StrategyComparison client:only="react" />
-
-## The Mathematics Behind It
-
-### Why Does the Cycle Length Matter?
-
-In a permutation of n elements, prisoner i will find their number within k tries using the loop strategy if and only if i belongs to a cycle of length at most k.
-
-For n = 100 and k = 50:
-- The probability that a specific prisoner is in a cycle of length > 50 is: Σ(j=51 to 100) of 1/100
-- But we care about whether ANY prisoner is in such a cycle
-- The probability that NO cycle has length > 50 is: 1 - Σ(j=51 to 100) of 1/j
-
-### The Harmonic Series Connection
-
-As *n* approaches infinity, if each prisoner can open *n*/2 boxes, the probability of success approaches:
-
-The limit as n approaches infinity is: P_n = 1 - ln(2) ≈ 0.3069
-
-This beautiful result connects combinatorics, probability, and analysis through the harmonic series!
-
-### Optimality
-
-Remarkably, this loop-following strategy is **optimal**. No other strategy can achieve a higher probability of success. The proof involves showing that the problem reduces to avoiding long cycles in a random permutation, and the loop strategy is the unique way to leverage this structure.
-
----
-
-## Why This Problem is Beautiful
-
-The 100 prisoners problem is beloved by mathematicians because:
-
-1. **Counterintuitive Result**: The fact that 31% >> 0% is shocking. A seemingly hopeless problem becomes tractable with the right insight.
-
-2. **Deep Connection**: It connects permutation theory, probability, and the harmonic series in an elegant way.
-
-3. **Collaborative Success**: Unlike independent trials, the prisoners' fates are intertwined through the structure of the permutation.
-
-4. **Real-World Metaphor**: It illustrates how understanding underlying structure (cycles in permutations) can dramatically improve outcomes.
-
----
-
-## Variants and Extensions
-
-### What if prisoners can open k < n/2 boxes?
-
-As k decreases below n/2, the probability drops rapidly. The threshold at n/2 is special—it's where the strategy becomes remarkably effective.
-
-### What about communication?
-
-If prisoners could communicate between trials (but not during), they still can't improve the strategy. The beauty is that the strategy requires only coordination before any prisoner enters, not during.
-
-### The Malicious Director
-
-In an interesting variant, suppose the director can see the prisoners' strategy and arrange the boxes adversarially (not randomly). Can the director always force them to fail? Yes! The director can always create a single cycle of length n, guaranteeing failure.
-
----
-
-## Conclusion
-
-The 100 prisoners problem shows us that:
-- Mathematical structure can be hidden in apparent randomness
-- Clever strategies can overcome seemingly impossible odds
-- Group coordination can be more powerful than independent action
-- Beautiful mathematics often lies beneath simple-seeming puzzles
-
-The next time you face a problem that seems impossible, remember: there might be a hidden structure waiting to be discovered, turning hopeless odds into reasonable ones.
-
----
-
-## Further Reading
-
-- [Gál, A., & Miltersen, P. B. (2003). "The Cell Probe Complexity of Succinct Data Structures"](https://arxiv.org/abs/cs/0310027)
-- [Curtin, E., & Warshauer, M. (2006). "The Locker Puzzle"](https://www.jstor.org/stable/27642173)
-- [Wikipedia: 100 Prisoners Problem](https://en.wikipedia.org/wiki/100_prisoners_problem)
-
diff --git a/sites/vibes/src/content/puzzles/dynamic-programming-gems.md b/sites/vibes/src/content/puzzles/dynamic-programming-gems.md
deleted file mode 100644
index 79e68ea..0000000
--- a/sites/vibes/src/content/puzzles/dynamic-programming-gems.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "Dynamic Programming: Hidden Gems from Recent Contests"
-description: "Elegant dynamic programming problems that showcase beautiful techniques and insights."
-pubDate: "Jan 25 2024"
-image: "https://images.unsplash.com/photo-1509228468518-180dd4864904?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Dynamic Programming: Hidden Gems from Recent Contests
-
-These problems demonstrate the art of dynamic programming beyond standard patterns.
-
-## Problem 1: The Subsequence Symphony
-
-Given a string, find the number of subsequences that form palindromes of prime length.
-
-### Solution Insight
-
-The key is to maintain DP states for both position and palindrome center simultaneously. This reduces the state space from O(n³) to O(n²).
-
-## Problem 2: Graph Coloring with Constraints
-
-Color a graph such that no two adjacent vertices share a color, and the total number of color changes along any path is minimized.
-
-### The DP Formulation
-
-DP[node][color][changes] gives us the minimum cost. The trick is recognizing that we only need to track changes modulo 2.
-
-## Practice Makes Perfect
-
-These problems teach us that DP is as much about problem modeling as it is about computation.
diff --git a/sites/vibes/src/content/puzzles/four-aces-miracle.md b/sites/vibes/src/content/puzzles/four-aces-miracle.md
deleted file mode 100644
index a1710ab..0000000
--- a/sites/vibes/src/content/puzzles/four-aces-miracle.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "The Four Aces Miracle: A Self-Working Mathematical Marvel"
-description: "A card trick that teaches modular arithmetic and probability - perfect for the classroom."
-pubDate: "Jan 28 2024"
-image: "https://images.unsplash.com/photo-1529480384838-c1681c84aca5?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# The Four Aces Miracle: A Self-Working Mathematical Marvel
-
-This trick never fails to amaze students, and the mathematics behind it is even more amazing.
-
-## The Effect
-
-A spectator deals cards into four piles while making random choices. Impossibly, the four aces end up on top of each pile.
-
-## The Secret
-
-It's all about invariants and modular arithmetic. No sleight of hand required - pure mathematics does the magic.
-
-## The Method
-
-1. Pre-arrange the deck (the math determines the arrangement)
-2. Have the spectator deal following simple rules
-3. The aces appear automatically
-
-## The Mathematics
-
-The dealing process preserves certain positional invariants modulo 4. The initial arrangement ensures these invariants place the aces correctly.
-
-## Teaching Applications
-
-This trick demonstrates:
-- Modular arithmetic
-- Invariants in algorithms
-- Deterministic vs. random processes
-
-## The Bigger Lesson
-
-Mathematics can create experiences that feel like magic. And that feeling of wonder? That's what hooks students on math.
diff --git a/sites/vibes/src/content/puzzles/gilbreath-principle.md b/sites/vibes/src/content/puzzles/gilbreath-principle.md
deleted file mode 100644
index 92e229b..0000000
--- a/sites/vibes/src/content/puzzles/gilbreath-principle.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: "The Gilbreath Principle: When Chaos Creates Order"
-description: "A mathematical card principle that seems impossible but always works - perfect for teaching algorithms."
-pubDate: "Feb 15 2024"
-image: "https://images.unsplash.com/photo-1570543375343-63fe3d67761b?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# The Gilbreath Principle: When Chaos Creates Order
-
-Shuffle a deck in a specific way, and mathematical order emerges from apparent chaos.
-
-## The Phenomenon
-
-Arrange cards alternating red-black. Riffle shuffle. Now deal pairs - each pair has one red and one black card. Magic? No, mathematics.
-
-## Why It Works
-
-The riffle shuffle preserves local structure while appearing to randomize. The alternating pattern creates an invariant that survives the shuffle.
-
-## Classroom Implementation
-
-Students predict it won't work. When it does, they're hooked. "Why?" becomes the driving question.
-
-## The Deeper Lesson
-
-Not all randomness is truly random. Structure can hide in apparent disorder. This principle appears in:
-- Network protocols
-- Error-correcting codes  
-- Distributed systems
-
-## Beyond Cards
-
-The Gilbreath Principle teaches us to look for hidden invariants in complex systems.
diff --git a/sites/vibes/src/content/puzzles/graph-algorithms-assessment.md b/sites/vibes/src/content/puzzles/graph-algorithms-assessment.md
deleted file mode 100644
index 4c61fe2..0000000
--- a/sites/vibes/src/content/puzzles/graph-algorithms-assessment.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "Graph Algorithms: Assessment Highlights"
-description: "Interesting graph problems from recent course assessments with detailed solutions."
-pubDate: "Feb 28 2024"
-image: "https://images.unsplash.com/photo-1550751827-4bd374c3f58b?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Graph Algorithms: Assessment Highlights
-
-A collection of graph problems that test deep understanding rather than memorization.
-
-## The Bridge Detection Variant
-
-Find all edges whose removal increases the number of triangles in the graph.
-
-### Solution Approach
-
-Counter-intuitively, we need to count triangles that share exactly one edge with the candidate. The algorithm runs in O(m√m) time using careful enumeration.
-
-## Shortest Path with Wildcards
-
-Given a graph where some edge weights are variables, find assignments that minimize the longest shortest path.
-
-### Key Insight
-
-This reduces to a linear programming problem with interesting structure. The dual interpretation reveals connections to network flow.
-
-## Teaching Through Problems
-
-These problems help students see beyond standard algorithms to underlying principles.
diff --git a/sites/vibes/src/content/puzzles/ioi-2023-analysis.md b/sites/vibes/src/content/puzzles/ioi-2023-analysis.md
deleted file mode 100644
index 782177c..0000000
--- a/sites/vibes/src/content/puzzles/ioi-2023-analysis.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "IOI 2023: Breaking Down the Hardest Problems"
-description: "Deep analysis of the most challenging problems from the International Olympiad in Informatics 2023."
-pubDate: "Jan 20 2024"
-image: "https://images.unsplash.com/photo-1434030216411-0b793f4b4173?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# IOI 2023: Breaking Down the Hardest Problems
-
-The International Olympiad in Informatics continues to push the boundaries of algorithmic problem solving.
-
-## Problem: Soccer Stadium
-
-A geometric optimization problem disguised as dynamic programming. The key insight: think in terms of monotonic paths.
-
-### The Approach
-
-1. Transform the 2D problem into a 1D problem using clever observations
-2. Use convex hull optimization for the DP transitions
-3. Handle edge cases with careful implementation
-
-## Problem: Closing Time
-
-A tree problem requiring sophisticated data structures and careful analysis.
-
-### The Solution
-
-The trick is recognizing this as a centroid decomposition problem. Once you see it, the implementation follows naturally.
-
-## Lessons for Students
-
-These problems teach us:
-- Simple problems have elegant solutions
-- Complex problems require systematic decomposition
-- Implementation matters as much as algorithms
-
-## Practice Strategy
-
-Start with subtasks. Even partial solutions teach valuable lessons.
diff --git a/sites/vibes/src/content/puzzles/knights-tour-interactive.md b/sites/vibes/src/content/puzzles/knights-tour-interactive.md
deleted file mode 100644
index eec6960..0000000
--- a/sites/vibes/src/content/puzzles/knights-tour-interactive.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: "The Knight's Tour: An Interactive Exploration"
-description: "An interactive puzzle exploring the knight's tour problem with surprising mathematical connections."
-pubDate: "Jan 30 2024"
-image: "https://images.unsplash.com/photo-1528819622765-d6bcf132f793?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# The Knight's Tour: An Interactive Exploration
-
-Can a knight visit every square on a chessboard exactly once? This ancient puzzle hides deep mathematical structure.
-
-## The Basic Challenge
-
-Start with a 5×5 board. Can you find a knight's tour? What about one that returns to the starting square (a closed tour)?
-
-## Mathematical Beauty
-
-The problem connects to:
-- Hamiltonian paths in graphs
-- Warnsdorff's heuristic
-- Magic squares (surprisingly!)
-
-## The Algorithm
-
-The key insight: always move to the square with fewest onward moves. This simple heuristic works remarkably well.
-
-## Try It Yourself
-
-[Interactive board would go here - imagine clicking squares to build your tour]
-
-## Going Deeper
-
-For which board sizes do closed tours exist? The answer involves beautiful number theory.
diff --git a/sites/vibes/src/content/puzzles/projecteuler-favorites.md b/sites/vibes/src/content/puzzles/projecteuler-favorites.md
deleted file mode 100644
index 16988a9..0000000
--- a/sites/vibes/src/content/puzzles/projecteuler-favorites.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: "Project Euler: My Favorite Problems from 700+"
-description: "Curated problems from Project Euler that teach beautiful mathematical and algorithmic concepts."
-pubDate: "Feb 25 2024"
-image: "https://images.unsplash.com/photo-1635070041078-e363dbe005cb?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Project Euler: My Favorite Problems from 700+
-
-After solving 700+ Project Euler problems, these are the ones that changed how I think about mathematics and programming.
-
-## Problem 96: Su Doku
-
-Not just Sudoku solving - but solving 50 puzzles efficiently. The beauty is in combining constraint propagation with backtracking.
-
-## Problem 208: Robot Walks
-
-A counting problem that requires deep mathematical insight. The connection to complex numbers is unexpected and beautiful.
-
-## Problem 613: Pythagorean Ant
-
-Probability meets geometry in this elegant problem. The solution requires careful integration and surprising symmetry observations.
-
-## The Meta-Lesson
-
-Project Euler teaches you:
-- Mathematical intuition matters more than coding speed
-- There's always a clever approach
-- The journey matters more than the destination
-
-## Getting Started
-
-Don't aim for the leaderboard. Aim for understanding. Each problem is a teacher.
diff --git a/sites/vibes/src/content/puzzles/sudoku-variants.md b/sites/vibes/src/content/puzzles/sudoku-variants.md
deleted file mode 100644
index 1efd136..0000000
--- a/sites/vibes/src/content/puzzles/sudoku-variants.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-title: "Beyond Sudoku: Exploring Constraint Satisfaction Puzzles"
-description: "A journey through Sudoku variants and their algorithmic solutions."
-pubDate: "Feb 10 2024"
-image: "https://images.unsplash.com/photo-1580541631950-7282082b53ce?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Beyond Sudoku: Exploring Constraint Satisfaction Puzzles
-
-Sudoku is just the beginning. Let's explore variants that push the boundaries of logic puzzles.
-
-## Killer Sudoku
-
-Combine Sudoku with Kakuro - cages show sums, but no digit repeats within a cage.
-
-## Sandwich Sudoku
-
-The numbers outside show the sum of digits between 1 and 9 in that row/column. Simple rule, complex implications!
-
-## The Algorithm Connection
-
-These puzzles are constraint satisfaction problems. Techniques like arc consistency and backtracking with constraint propagation solve them efficiently.
-
-## Create Your Own
-
-What happens if we add chess knight move constraints? The design space is infinite!
diff --git a/sites/vibes/src/content/reflections/imposter-syndrome.md b/sites/vibes/src/content/reflections/imposter-syndrome.md
deleted file mode 100644
index e0a77e0..0000000
--- a/sites/vibes/src/content/reflections/imposter-syndrome.md
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: "Imposter Syndrome in Academia: A Confession"
-description: "An honest conversation about feeling like a fraud, even after years of success."
-pubDate: "Feb 25 2024"
-image: "https://images.unsplash.com/photo-1517048676732-d65bc937f952?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Imposter Syndrome in Academia: A Confession
-
-Even after publishing papers, winning grants, and teaching thousands of students, the voice whispers: "They'll find out you don't belong."
-
-## The Paradox
-
-The more you know, the more you realize you don't know. Expertise breeds humility, which feeds the imposter.
-
-## What Helps
-
-- Keeping a "wins" journal - evidence against the imposter
-- Mentoring others - seeing your knowledge help someone
-- Talking about it - you're not alone in this
-
-## The Silver Lining
-
-Maybe imposter syndrome keeps us humble, curious, and always learning. Maybe it's not a bug, but a feature.
-
-## Moving Forward
-
-I may never silence the voice completely. But I've learned to acknowledge it and keep going anyway.
diff --git a/sites/vibes/src/content/reflections/teaching-philosophy.md b/sites/vibes/src/content/reflections/teaching-philosophy.md
deleted file mode 100644
index fc1a0f2..0000000
--- a/sites/vibes/src/content/reflections/teaching-philosophy.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "On Teaching Algorithms: Lessons from a Decade"
-description: "Reflections on what works (and what doesn't) in computer science education."
-pubDate: "Jan 10 2024"
-image: "https://images.unsplash.com/photo-1509062522246-3755977927d7?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# On Teaching Algorithms: Lessons from a Decade
-
-Ten years of teaching has taught me more than any textbook could.
-
-## Start with Why
-
-Students don't care about O(n log n) until they understand why their code is slow. Real problems first, theory second.
-
-## The Power of Visualization
-
-Abstract concepts become concrete when visualized. Every algorithm should have a picture.
-
-## Failure is a Feature
-
-Let students struggle. The struggle is where learning happens. But know when to throw a lifeline.
-
-## Assessment Philosophy
-
-Test understanding, not memorization. Open-book exams with novel problems beat closed-book regurgitation every time.
-
-## The Joy of "Aha!" Moments
-
-There's no feeling quite like seeing a student's eyes light up when a concept clicks. That's why we do this.
diff --git a/sites/vibes/src/content/research/conference-highlights-2024.md b/sites/vibes/src/content/research/conference-highlights-2024.md
deleted file mode 100644
index 73b6741..0000000
--- a/sites/vibes/src/content/research/conference-highlights-2024.md
+++ /dev/null
@@ -1,34 +0,0 @@
----
-title: "SODA 2024: Algorithmic Breakthroughs"
-description: "A roundup of fascinating algorithmic results from SODA 2024, focusing on graph algorithms and optimization techniques."
-pubDate: "Jan 15 2024"
-image: "https://images.unsplash.com/photo-1509228468518-180dd4864904?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# SODA 2024: Algorithmic Breakthroughs
-
-The Symposium on Discrete Algorithms (SODA) 2024 brought together researchers from around the world to present cutting-edge algorithmic research. This post highlights some of the most exciting developments in graph algorithms and optimization.
-
-## Graph Algorithms Revolution
-
-### Dynamic Graph Coloring
-
-One of the standout papers introduced a breakthrough in dynamic graph coloring with polylogarithmic update time. The authors developed a novel data structure that maintains a proper vertex coloring while supporting edge insertions and deletions efficiently.
-
-The key insight was to combine randomized recoloring strategies with a carefully designed hierarchical decomposition of the graph. This allows for local updates that rarely propagate through the entire structure.
-
-## Approximation Algorithms
-
-### The Traveling Salesman Problem Revisited
-
-A surprising result showed that for graphs with bounded doubling dimension, we can achieve a (1+ε)-approximation for TSP in nearly linear time. This improves upon decades of previous work and opens new avenues for practical implementations.
-
-## Complexity Theory Connections
-
-The conference also featured several papers bridging the gap between pure algorithmic research and complexity theory. A particularly elegant result showed that certain graph problems believed to require quadratic time are equivalent under fine-grained reductions.
-
-## Looking Forward
-
-These results demonstrate that fundamental algorithmic problems still have room for improvement. The techniques developed here will likely influence algorithm design for years to come.
diff --git a/sites/vibes/src/content/research/distributed-algorithms.md b/sites/vibes/src/content/research/distributed-algorithms.md
deleted file mode 100644
index e577220..0000000
--- a/sites/vibes/src/content/research/distributed-algorithms.md
+++ /dev/null
@@ -1,34 +0,0 @@
----
-title: "Distributed Computing: Recent Advances"
-description: "Survey of recent developments in distributed algorithms from major conferences."
-pubDate: "Feb 20 2024"
-image: "https://images.unsplash.com/photo-1558618666-fcd25c85cd64?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Distributed Computing: Recent Advances
-
-The field of distributed computing has seen remarkable progress in recent years. This post surveys key results from PODC, DISC, and other major venues.
-
-## Consensus Protocols
-
-### Byzantine Agreement in Asynchronous Networks
-
-A breakthrough result achieves optimal resilience with expected constant rounds. The protocol uses cryptographic techniques combined with novel committee selection.
-
-## Distributed Graph Algorithms
-
-### Minimum Spanning Tree in the CONGEST Model
-
-New algorithms achieve near-optimal round complexity for MST construction. The approach uses sophisticated graph decomposition techniques.
-
-## Local Algorithms
-
-### The Power of Local Computation
-
-Recent work characterizes which problems admit constant-time local algorithms. The classification provides a complete picture for bounded-degree graphs.
-
-## Future Directions
-
-The intersection of distributed computing with machine learning presents exciting opportunities for both fields.
diff --git a/sites/vibes/src/content/research/git-automation.md b/sites/vibes/src/content/research/git-automation.md
deleted file mode 100644
index 2ae09cd..0000000
--- a/sites/vibes/src/content/research/git-automation.md
+++ /dev/null
@@ -1,54 +0,0 @@
----
-title: "Git Workflows That Save My Sanity"
-description: "Automation scripts and Git hooks that eliminate repetitive tasks and prevent common mistakes."
-pubDate: "Jan 22 2024"
-image: "https://images.unsplash.com/photo-1556075798-4825dfaaf498?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Git Workflows That Save My Sanity
-
-After years of Git mishaps, I've built workflows that prevent disasters and save hours weekly.
-
-## The Pre-commit Hook That Saves Embarrassment
-
-```bash
-#!/bin/bash
-# Check for debugging statements
-if grep -r "console.log\|debugger\|TODO" --include="*.js" .; then
-  echo "⚠️  Debugging statements found!"
-  exit 1
-fi
-```
-
-## Automatic Branch Naming
-
-```bash
-alias feature='git checkout -b feature/$(date +%Y%m%d)-$1'
-```
-
-Now `feature "user-auth"` creates `feature/20240122-user-auth`.
-
-## The Commit Message Template
-
-```
-[TYPE] Brief description
-
-Why:
-- Context for this change
-
-What:
-- Specific changes made
-
-Testing:
-- How to verify it works
-```
-
-## The Weekly Cleanup Script
-
-Deletes merged branches, prunes remotes, and garbage collects. Keeps the repo clean and fast.
-
-## ROI
-
-These automations save ~5 hours per week and countless prevented mistakes. The time invested in setting them up paid back in days.
diff --git a/sites/vibes/src/content/research/obsidian-academic.md b/sites/vibes/src/content/research/obsidian-academic.md
deleted file mode 100644
index 7e1c181..0000000
--- a/sites/vibes/src/content/research/obsidian-academic.md
+++ /dev/null
@@ -1,41 +0,0 @@
----
-title: "Academic Writing with Obsidian and Pandoc"
-description: "A complete workflow for academic papers - from notes to publication-ready PDFs."
-pubDate: "Feb 12 2024"
-image: "https://images.unsplash.com/photo-1456324504439-367cee3b3c32?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Academic Writing with Obsidian and Pandoc
-
-Transform your scattered research notes into beautiful academic papers with this workflow.
-
-## The Setup
-
-- **Obsidian**: For note-taking and knowledge management
-- **Pandoc**: For document conversion
-- **LaTeX**: For typesetting
-- **Zotero**: For reference management
-
-## The Magic Command
-
-```bash
-pandoc paper.md \
-  --filter pandoc-citeproc \
-  --bibliography=refs.bib \
-  --template=academic.tex \
-  -o paper.pdf
-```
-
-## Templates for Everything
-
-From conference submissions to journal articles, templates ensure consistency and save time.
-
-## Version Control Integration
-
-Git + Obsidian = perfect history of your thinking process.
-
-## The Result
-
-From messy notes to camera-ready PDF in minutes, not hours.
diff --git a/sites/vibes/src/content/research/paper-review-approximation.md b/sites/vibes/src/content/research/paper-review-approximation.md
deleted file mode 100644
index 10d7c78..0000000
--- a/sites/vibes/src/content/research/paper-review-approximation.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "Understanding the Latest Approximation Algorithm for Set Cover"
-description: "A detailed walkthrough of a breakthrough approximation algorithm with practical implications."
-pubDate: "Feb 15 2024"
-image: "https://images.unsplash.com/photo-1516321318423-f06f85e504b3?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Understanding the Latest Approximation Algorithm for Set Cover
-
-A recent paper achieves a breakthrough in the Set Cover problem, improving the approximation ratio while maintaining practical runtime.
-
-## The Algorithm
-
-The approach combines local search with a clever LP rounding scheme. The dual interpretation provides beautiful geometric insights.
-
-## Why This Matters
-
-Set Cover appears everywhere - from facility location to machine learning feature selection. This improvement has immediate practical impact.
-
-## Implementation Details
-
-The paper's theoretical elegance translates surprisingly well to practice. Key optimizations include:
-- Lazy evaluation of set intersections
-- Incremental updates to the LP solution
-- Smart caching strategies
-
-## Future Work
-
-The techniques here might extend to weighted variants and online settings.
diff --git a/sites/vibes/src/content/research/paper-review-graph-decomposition.md b/sites/vibes/src/content/research/paper-review-graph-decomposition.md
deleted file mode 100644
index f0e4868..0000000
--- a/sites/vibes/src/content/research/paper-review-graph-decomposition.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "Deep Dive: A New Approach to Graph Decomposition"
-description: "An in-depth analysis of a recent paper on hierarchical graph decomposition and its implications."
-pubDate: "Jan 20 2024"
-image: "https://images.unsplash.com/photo-1507003211169-0a1dd7228f2d?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Deep Dive: A New Approach to Graph Decomposition
-
-This paper introduces a novel framework for decomposing graphs into hierarchical structures that preserve important properties while enabling efficient algorithms.
-
-## The Main Result
-
-The authors prove that every graph with treewidth k can be decomposed into a tree of bags where each bag has size at most k+1. While this sounds like the definition of tree decomposition, the clever twist is in how they construct it.
-
-## Technical Innovation
-
-The key insight is using a charging scheme that amortizes the cost of decomposition across multiple levels. This leads to an O(n log n) algorithm, improving on the previous O(n²) bound.
-
-## Implications
-
-This work opens new avenues for:
-- Parallel algorithms on bounded treewidth graphs
-- Approximation algorithms for NP-hard problems
-- Dynamic programming optimizations
-
-## Open Questions
-
-The paper leaves several intriguing questions open, particularly about the optimality of their charging scheme.
diff --git a/sites/vibes/src/content/research/quantum-algorithms.md b/sites/vibes/src/content/research/quantum-algorithms.md
deleted file mode 100644
index 0eef5b2..0000000
--- a/sites/vibes/src/content/research/quantum-algorithms.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: "Quantum Computing Meets Classical Algorithms"
-description: "Exploring the intersection of quantum and classical algorithmic techniques from recent conferences."
-pubDate: "Mar 10 2024"
-image: "https://images.unsplash.com/photo-1635070041078-e363dbe005cb?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Quantum Computing Meets Classical Algorithms
-
-Recent conferences have showcased fascinating connections between quantum and classical computing paradigms.
-
-## Quantum Speedups for Graph Problems
-
-### Quantum Walks on Graphs
-
-New quantum algorithms achieve quadratic speedups for certain graph traversal problems. The techniques combine amplitude amplification with clever graph representations.
-
-## Classical Simulation of Quantum Algorithms
-
-Surprisingly, several "quantum" algorithms have inspired better classical algorithms. This cross-pollination has led to improvements in both fields.
-
-## The Future is Hybrid
-
-The most practical near-term applications combine quantum and classical processing, leveraging the strengths of each paradigm.
diff --git a/sites/vibes/src/content/reviews/mechanical-keyboard.md b/sites/vibes/src/content/reviews/mechanical-keyboard.md
deleted file mode 100644
index 0346a78..0000000
--- a/sites/vibes/src/content/reviews/mechanical-keyboard.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: "ZSA Moonlander: Ergonomic Keyboard for Coders"
-description: "Six months with a split ergonomic mechanical keyboard - the good, the bad, and the RSI relief."
-pubDate: "Feb 20 2024"
-image: "https://images.unsplash.com/photo-1587829741301-dc798b83add3?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# ZSA Moonlander: Ergonomic Keyboard for Coders
-
-After years of wrist pain, I took the plunge into ergonomic mechanical keyboards.
-
-## The Learning Curve
-
-Week 1: 20 WPM and questioning life choices
-Week 2: 40 WPM and seeing the light
-Month 2: Back to 80 WPM with no wrist pain
-
-## The Good
-
-- Columnar layout makes sense once muscle memory adapts
-- Thumb clusters are game-changers for shortcuts
-- The configurability is endless (perhaps too endless)
-
-## The Investment
-
-At $365, it's expensive. But compared to physical therapy or career-limiting injury? Bargain.
-
-## Who Should Buy This?
-
-If you type for a living and feel any discomfort, don't wait. Your future self will thank you.
diff --git a/sites/vibes/src/content/reviews/obsidian-review.md b/sites/vibes/src/content/reviews/obsidian-review.md
deleted file mode 100644
index 599013f..0000000
--- a/sites/vibes/src/content/reviews/obsidian-review.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-title: "Obsidian: A Year Later"
-description: "Reflections on using Obsidian for research notes, teaching materials, and personal knowledge management."
-pubDate: "Jan 15 2024"
-image: "https://images.unsplash.com/photo-1484480974693-6ca0a78fb36b?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Obsidian: A Year Later
-
-After a year of daily use, Obsidian has transformed how I think about knowledge management.
-
-## What Works Brilliantly
-
-### The Graph View
-Seeing connections between ideas visually has led to unexpected research insights. The graph isn't just pretty - it's functional.
-
-### Plugin Ecosystem
-The community plugins are incredible. Dataview turns your notes into a database. Templater automates repetitive tasks.
-
-### Local Storage
-Your notes are just markdown files. No vendor lock-in, complete control, and peace of mind.
-
-## Pain Points
-
-### Mobile Experience
-While functional, the mobile app lacks the fluidity of the desktop version. Syncing can occasionally hiccup.
-
-### Learning Curve
-The flexibility means complexity. New users might feel overwhelmed by options.
-
-## The Verdict
-
-For academics and researchers, Obsidian is transformative. The investment in learning pays dividends in productivity and insight.
diff --git a/sites/vibes/src/content/vibes/13sheep/1.png b/sites/vibes/src/content/vibes/13sheep/1.png
new file mode 100644
index 0000000..63f4b6c
Binary files /dev/null and b/sites/vibes/src/content/vibes/13sheep/1.png differ
diff --git a/sites/vibes/src/content/vibes/13sheep/13sheep.png b/sites/vibes/src/content/vibes/13sheep/13sheep.png
new file mode 100644
index 0000000..0a2fbb2
Binary files /dev/null and b/sites/vibes/src/content/vibes/13sheep/13sheep.png differ
diff --git a/sites/vibes/src/content/vibes/13sheep/13sheep.webp b/sites/vibes/src/content/vibes/13sheep/13sheep.webp
new file mode 100644
index 0000000..bca4534
Binary files /dev/null and b/sites/vibes/src/content/vibes/13sheep/13sheep.webp differ
diff --git a/sites/vibes/src/content/vibes/13sheep/1a.png b/sites/vibes/src/content/vibes/13sheep/1a.png
new file mode 100644
index 0000000..1a3b028
Binary files /dev/null and b/sites/vibes/src/content/vibes/13sheep/1a.png differ
diff --git a/sites/vibes/src/content/vibes/13sheep/2.png b/sites/vibes/src/content/vibes/13sheep/2.png
new file mode 100644
index 0000000..57dfd4e
Binary files /dev/null and b/sites/vibes/src/content/vibes/13sheep/2.png differ
diff --git a/sites/vibes/src/content/vibes/13sheep/2a.png b/sites/vibes/src/content/vibes/13sheep/2a.png
new file mode 100644
index 0000000..0247119
Binary files /dev/null and b/sites/vibes/src/content/vibes/13sheep/2a.png differ
diff --git a/sites/vibes/src/content/vibes/13sheep/3.png b/sites/vibes/src/content/vibes/13sheep/3.png
new file mode 100644
index 0000000..b055a59
Binary files /dev/null and b/sites/vibes/src/content/vibes/13sheep/3.png differ
diff --git a/sites/vibes/src/content/vibes/13sheep/3a.png b/sites/vibes/src/content/vibes/13sheep/3a.png
new file mode 100644
index 0000000..34b36e2
Binary files /dev/null and b/sites/vibes/src/content/vibes/13sheep/3a.png differ
diff --git a/sites/vibes/src/content/vibes/13sheep/4.png b/sites/vibes/src/content/vibes/13sheep/4.png
new file mode 100644
index 0000000..bbcd67c
Binary files /dev/null and b/sites/vibes/src/content/vibes/13sheep/4.png differ
diff --git a/sites/vibes/src/content/vibes/13sheep/4a.png b/sites/vibes/src/content/vibes/13sheep/4a.png
new file mode 100644
index 0000000..36b6e60
Binary files /dev/null and b/sites/vibes/src/content/vibes/13sheep/4a.png differ
diff --git a/sites/vibes/src/content/vibes/13sheep/5.png b/sites/vibes/src/content/vibes/13sheep/5.png
new file mode 100644
index 0000000..f4e7168
Binary files /dev/null and b/sites/vibes/src/content/vibes/13sheep/5.png differ
diff --git a/sites/vibes/src/content/vibes/13sheep/5a.png b/sites/vibes/src/content/vibes/13sheep/5a.png
new file mode 100644
index 0000000..2e87236
Binary files /dev/null and b/sites/vibes/src/content/vibes/13sheep/5a.png differ
diff --git a/sites/vibes/src/content/vibes/13sheep/6.png b/sites/vibes/src/content/vibes/13sheep/6.png
new file mode 100644
index 0000000..b49f0fa
Binary files /dev/null and b/sites/vibes/src/content/vibes/13sheep/6.png differ
diff --git a/sites/vibes/src/content/vibes/13sheep/6a.png b/sites/vibes/src/content/vibes/13sheep/6a.png
new file mode 100644
index 0000000..7ea3d1e
Binary files /dev/null and b/sites/vibes/src/content/vibes/13sheep/6a.png differ
diff --git a/sites/vibes/src/content/vibes/13sheep/download.png b/sites/vibes/src/content/vibes/13sheep/download.png
new file mode 100644
index 0000000..caad543
Binary files /dev/null and b/sites/vibes/src/content/vibes/13sheep/download.png differ
diff --git a/sites/vibes/src/content/vibes/13sheep/finalui.png b/sites/vibes/src/content/vibes/13sheep/finalui.png
new file mode 100644
index 0000000..68134d3
Binary files /dev/null and b/sites/vibes/src/content/vibes/13sheep/finalui.png differ
diff --git a/sites/vibes/src/content/vibes/13sheep/index.md b/sites/vibes/src/content/vibes/13sheep/index.md
new file mode 100644
index 0000000..e6a12f5
--- /dev/null
+++ b/sites/vibes/src/content/vibes/13sheep/index.md
@@ -0,0 +1,328 @@
+---
+title: "13 Sheep"
+description: "13 Sheep happens to be a cute roll-and-write game designed by Moritz Dressler that involves protecting a bunch of sheep on a grid by placing small fences that have pre-defined s..."
+pubDate: "2023-03-26"
+authorName: "Neeldhara"
+sourceCategories: ["games", "exposition"]
+sourcePath: "13sheep/index.qmd"
+---
+
+[13 Sheep](https://www.moritzdressler.de/en/13_Sheep) happens to be a cute roll-and-write game designed by Moritz Dressler that involves protecting a bunch of sheep on a grid by placing small fences that have pre-defined shapes.
+
+![The Roll and Write Game](13sheep.png)
+
+The initial position of a certain number --- typically 13, as the name suggests --- of sheep over a 7x7 grid is given. Some grid edges are not available because there happen to be bushes: so you cannot fence them. The bushes do not protect the sheep either, the wolf can slide under them.
+
+Your goal is to enclose as many sheep as possible: the ones that are not fully protected by fences may, alas, be at considerable risk when the inevitable wolf attack happens.
+
+There are three main constrianing factors in this game:
+
+- The shape of the fences that you can draw are determined by the roll of a die;
+- You cannot overwrite lines that are already drawn, you cannot also draw over bushes;
+- You have ~11 chances to place your randomly gifted fence shapes.
+
+You can find out more about the game [here](https://www.moritzdressler.de/en/13_Sheep), where you can generate board layouts to print and play as well.
+
+I found this game a lot of fun to play, and I thought it would be lovely to be able to play it on a computer, where the user can decide how many rounds, sheep, and bushes they want to play with. Given also that chatGPT has been apparently [remarkably adept at coding games](https://twitter.com/ammaar/status/1637830530216390658?s=20), I figured I'd give it a shot^[Incidentally, I couldn't find a playable version like this one online. If you know of one please let me know and I'll be sure to add a pointer!].
+
+I describe my conversation with chatGPT below, but if you just want to cut to the case and check the game out, you can find the playable version [here](https://13sheep.netlify.app/) and the source [here](https://github.com/neeldhara/13sheep/).
+
+Here's what we finally built:
+
+![The 13 Sheep UI](finalui.png)
+
+And once you've finished playing you can share your accomplishment like so:
+
+![One of my completed games... where we protect five sheep, can you figure out how many rounds?](download.png)
+
+---
+
+So, back to chatGPT. My first prompt was just a polite inquiry about willingness to participate in this exercise:
+
+> **Note**
+> 
+> We want to code a game called 13 Sheep using HTML, CSS, and Javascript. Ready?
+
+
+And well, it immediately made [this](https://13-sheep-v3-GPT4-v30.neeldhara.repl.co), based on the prompt above: a game where you get to count to 13 sheep. Huh. Promising.
+
+In my next few prompts, I steered it away from the default game. The first few steps just involved setting up the UI:
+
+> **Note**
+> 
+> Great start! Please make the main canvas a square and draw a 7 x 7 grid in it. I want all the corners of the cells to look like small + signs. Do not draw any grid borders yet.
+
+
+> **Note**
+> 
+> Nice, how can I make the grid background mediumseagreen?
+
+
+> **Note**
+> 
+> On load, I want 13 grid cells to be identified at random, and the image sheep.png to be placed at their centers, appropriately scaled to fit.
+
+
+At this point I already had a nice-looking grid with 13 sheep on it (thanks to Flaticon for the cute sheep icon). The plus signs drawn on the boundary were oddly cropped out, so we fixed that next:
+
+> **Note**
+> 
+> Ok this looks great. Can you update the drawcross function so that crosses are also drawn on the grid boundary? And make the canvas a little bigger if needed so the entire cross is visible?
+
+
+This didn't immediately work but some nudging fixed it:
+
+> **Note**
+> 
+> The crosses at the bottom are getting cut off and now the sheep are off center. Please fix?
+
+
+That worked --- phew! Now we draw the bushes:
+
+> **Note**
+> 
+> Very nice. Can you randomly select 7 cells now and for each such cell make one of the cell boundaries colored indianred?
+
+
+Next we get the dice roll UI up:
+
+> **Note**
+> 
+> Excellent. Now please add six divs below the canvas, centered, evenly spaced, and with a light grey circular background, with the text 1, 2, 3, 4, 5, and 6 written inside them. Note that the first div should have the text 1, the second should have 2, and so on. Make sure the divs have at least 10px spacing between them.
+> 
+> Below these divs, please add a large button in the shape of a rounded rectangle, with the text "Roll Dice" written on it. The background color for this button should be indianred with a transparency of 0.42.
+
+
+This actually worked out of the box, the next step was to make the roll dice functional:
+
+> **Note**
+> 
+> Super nice!
+> 
+> Now can you make it so that when the user clicks on the button labeled "Roll Dice", we generate a number between 1 and 6 at random, and highlight the corresponding circular div by changing its background to Lavendar, while also resetting any previous highlight?
+
+
+So far, so good. Now all that was left was to get the fences drawn depending on what dice was rolled out.
+
+> **Tip**
+> 
+> 
+> # Fence Shapes Based on Dice Rolls
+> 
+> ![Dice Roll 1](1.png)
+> 
+> ---
+> 
+> ![Dice Roll 2](2.png)
+> 
+> ---
+> 
+> ![Dice Roll 3](3.png)
+> 
+> ---
+> 
+> ![Dice Roll 4](4.png)
+> 
+> ---
+> 
+> ![Dice Roll 5](5.png)
+> 
+> ---
+> 
+> ![Dice Roll 6](6.png)
+
+
+This was perhaps the trickiest bit. My first attempt was this prompt here:
+
+> **Note**
+> 
+> Great! Now can you update it so that:
+> 
+> if the outcome of the dice roll is a 1, the cursor should change to a shape that looks like a U, and nothing outside the grid should be clickable. If the user clicks on a grid cell, then the left, bottom, and right borders of the cell should change color and become a thick line colored in olivedrab. Once the user has clicked on a grid cell the cursor should change back to normal.
+> 
+> if the outcome of the dice roll is a 2, the cursor should change to a shape that looks like a long line, and nothing outside the grid should be clickable, and none of the cells in the last column should be clickable either. If the user clicks on a grid cell, then the bottom border of the cell should change color and become a thick line colored in olivedrab, and the the bottom border of the horizontally adjacent cell should change color and become a thick line colored in olivedrab. Once the user has clicked on a grid cell the cursor should change back to normal.
+
+
+My hope was that the change of cursor would be a good way for the player to register that they need to move on the grid now. At this point, I was not thinking about the different orientations of the fences, because I was not sure about how to incorporate that into the UI (my first thought was to have the fences rotate on subsequent clicks until the player clicks on a confirm button, but that seemed too messy). I also did not give all six scenarios in one go since --- from recent experience --- the interface dies out on longer requests. You can prod it to continue from where it left off, but it's typically messy.
+
+In any case, we could not get the change of cursor to work. At this point, note that the code is also not tracking what borders are colored, so even as we got things to mildly work, we were often overwriting fences and bushes. So anyway, at some point I gave up and it was back to square one, but smaller steps. First, instead of a change of cursor, I just requested a canvas background color change to subtly communicate a change of game state:
+
+> **Note**
+> 
+> Once the dice roll button is clicked, can you change the background of the canvas to dodgerblue with transparency 0.42, and disable the roll dice button until the user clicks on a grid cell?
+
+
+Then we added a round tracker:
+
+> **Note**
+> 
+> Add the following text just below the "Roll Dice" button: "Roll a dice now, 11 rounds left". Every time the user clicks on "Roll Dice", change the text to "Place a fence now." Once the user clicks on a grid cell, change the text back to "Roll a dice now, 11 rounds left", but decrease the number of rounds by one each time. Can you do this?
+
+
+This took some back and forth to get working, since it was getting some details mixed up, but it was finally alright. I had to prompt more to take care of some edge cases and minor details, for instance:
+
+
+> **Note**
+> 
+> Anyway, can you make it so that when there are 0 rounds left, the text simply says "Game Over"?
+> 
+> Also when the roll dice button is not active, can it have a grey background? Only when it is not active.
+
+
+Now we are back to actually trying to get the fences to be drawn. With some nervousness, I go:
+
+
+> **Note**
+> 
+> Very nice. Now, if the dice roll is a 1 and the user clicks on a grid cell, can you do the following?
+> 
+> 1. let us say that a cell is valid if the top, left, and bottom borders of the grid have no visible borders.
+> 2. if the cell is valid, then make its top, left, and bottom borders colored olivedrab.
+
+
+At this point the code generated starts tracking what borders are visible. I did have to prompt it explicitly to update the earlier function that generated the bushes to feed into the visibility states. However, this went off pretty smoothly overall. For quite some time the fences drawn when the user clicked a grid cell were not the ones I wanted, but after a few nudges it got it about right.
+
+Now it occured to me that I could actually show the orientations after the dice is rolled and the user can select one of them, and we can draw the appropriate fence after this selection is made.
+
+> **Note**
+> 
+> Great. This works. Now below the instruction-text element, please add another div with ID "orientation-select" that begins with the text: "Pick an orientation". Below this, add four circular divs with a light grey backgorund with the content: "0", "90", "180", "270". This div should only be visible when the gamestate is "chooseFenceOrientation" or "placeFence".
+> 
+> Once a dice is rolled, the game state should change to chooseFenceOrientation and the user should be allowed to click any of these four divs. Once the user clicks one of the four divs, highlight it with the color burntorange and change the gamestate to placeFence. Store the choice of which div the user clicked on in a variable called fenceorientation and change the game state to placeFence.
+> 
+> Once the user clicks on a grid cell, clear the burntorange highlight and hide the "orientation-select" div, as it should not be visible any more.
+
+
+Of course in the UI at the moment we just have these four numbers so it does not make a lot of sense to the player, so I whipped some images to show the user what fences would be drawn depending on what grid cell was clicked.
+
+Now we come back to the fence drawing thing to account for the orientations as well:
+
+
+> **Note**
+> 
+> In the handleGridClick() function, we want to implement the following functionality.
+> 
+> If the outcome is 1 and the orientation is 0, then do the following when the user clicks on a grid cell.
+> 
+> 1. let us say that a cell is valid if the top, left, and bottom borders of the grid have no visible borders.
+> 2. if the cell is valid, then make its top, left, and bottom borders colored olivedrab.
+> 
+> 
+> If the outcome is 1 and the orientation is 90, then do the following when the user clicks on a grid cell.
+> 
+> 1. let us say that a cell is valid if the right, left, and bottom borders of the grid have no visible borders.
+> 2. if the cell is valid, then make its right, left, and bottom borders colored olivedrab.
+> 
+> 
+> If the outcome is 1 and the orientation is 180, then do the following when the user clicks on a grid cell.
+> 
+> 1. let us say that a cell is valid if the right, top, and bottom borders of the grid have no visible borders.
+> 2. if the cell is valid, then make its right, top, and bottom borders colored olivedrab.
+> 
+> 
+> If the outcome is 1 and the orientation is 270, then do the following when the user clicks on a grid cell.
+> 
+> 1. let us say that a cell is valid if the right, left, and top borders of the grid have no visible borders.
+> 2. if the cell is valid, then make its right, left, and top borders colored olivedrab.
+> 
+> Please remember to use the drawBorder function from before as you work out these cases. Also remember to update the grid visibility values, for the two relevant cells per border drawn. Thanks.
+
+
+Getting this going for all the 20 different cases was really the bulk of the back and forth. While it got the overall functionality right, there would be small and frequent bugs in the details. For instance, if a cell's top border is being fenced, then the cell above it should have its bottom border's visibility updated: it knows this, but frequently got combinations wrong, and so I did have to read the code generated carefully. I either fixed it manually when the bugs were minor, or went back to requesting corrections by explaining the issue when it was off by a whole lot.
+
+You can see that some of the prompts are longer than the corresponding code :D
+
+
+> **Note**
+> 
+> Looks great! Lets continue with our updates. Please remember to account for all the cases when updating the grid visibility values.
+> 
+> If the outcome is 4 and the orientation is 0, then do the following when the user clicks on a grid cell.
+> 
+> 1. let us say that a cell is valid if its bottom and left borders are not visible and the horizontally adjacent cell (i.e, the cell to the right of it) also does not have a bottom border. if a cell is on the right-most column, it is automatically not valid.
+> 2. if the cell is valid, then make its bottom and left borders colored olivedrab. Also make the bottom border of the horizontally adjacent cell colored olivedrab. Update the grid visibility values as appropriate.
+> 
+> If the outcome is 4 and the orientation is 180, then do the following when the user clicks on a grid cell.
+> 
+> 1. let us say that a cell is valid if its top border is not visible and the horizontally adjacent cell (i.e, the cell to the right of it) also does not have a top border and the horizontally adjacent cell (i.e, the cell to the right of it) also does not have a right border. if a cell is on the right-most column, it is automatically not valid.
+> 2. if the cell is valid, then make its top border colored olivedrab. Also make the top border of the horizontally adjacent cell colored olivedrab. Also make the right border of the horizontally adjacent cell colored olivedrab.  Update the grid visibility values as appropriate.
+> 
+> If the outcome is 4 and the orientation is 90, then do the following when the user clicks on a grid cell.
+> 
+> 1. let us say that a cell is valid if its top and left borders are not visible and the vertically adjacent cell (i.e, the cell below it) also does not have a left border. if a cell is on the right-most column, it is automatically not valid.
+> 2. if the cell is valid, then make its top and left borders colored olivedrab. Also make the left border of the vertically adjacent cell colored olivedrab. Update the grid visibility values as appropriate.
+> 
+> If the outcome is 4 and the orientation is 270, then do the following when the user clicks on a grid cell.
+> 
+> 1. let us say that a cell is valid if its bottom and right borders are not visible and the vertically adjacent cell (i.e, the cell to the top of it) also does not have a right border. if a cell is on the right-most column, it is automatically not valid.
+> 2. if the cell is valid, then make its bottom and right borders colored olivedrab. Also make the right border of the vertically adjacent cell colored olivedrab. Update the grid visibility values as appropriate.
+
+
+Maybe it'll soon be possible to just upload a picture of the game instruction booklet and let chatGPT do the rest of the heavy lifting. Until then, this was the best I could think of: maybe there's a shorter way? I did try using generic shape descriptions, but no luck on those.
+
+Now the basic game was done, and there were three main features I'd have really liked to add at this point:
+
+- Allow the user undo the previous fence placement.
+- Count the number of protected sheep at the end.
+- Make a version of this game where instead of rolling a dice, we let the user pick the fences they want: this can be useful for a multiplayer setting where we want the random choices to be the same for all players: so one player can roll the dice and the others can follow along.
+
+I did try some of this: it's impressive that chatGPT gets the main ideas right the first two requirements (the use of an action stack for implementing undo, and recognizing that we need some kind of flood fill algorithm for the score). However, all the implementations ended up being somewhat buggy and after some wrestling I decided to push these extras to the roadmap. The deterministic version of the game should not be hard to make, even manually at this point, so I hope to come back to it soon.
+
+After this I mainly asked for chatGPT to let the user customize the parameters of the game:
+
+
+> **Note**
+> 
+> Can you make it so that when the page loads we ask the user (via an alert) for a number between 7 and 32 and set the number of rounds to the number specified by the user?
+
+
+It got this immediately right, and I wanted some styling:
+
+> **Note**
+> 
+> Can you add some css styling so that this prompt looks nice?
+
+
+and it's response was:
+
+> **Tip**
+> 
+> Unfortunately, you cannot directly style the default JavaScript prompt function. Instead, you can create a custom modal using HTML, CSS, and JavaScript to achieve a more visually appealing and flexible solution.
+> 
+> Here's an example of how you can create a custom modal to ask for the number of rounds:
+> 
+> ...
+
+
+Good to know! The modals worked out of the box, and it was easy to extend them so they asked for the number of sheep and bushes as well. The last thing I wanted to add was a sharing feature:
+
+> **Note**
+> 
+> Can you add code so that the user can share a screenshot of just the canvas once the game is over? So once the game is over, I want to show a link called "Share My Game!" The screenshot and options to share on social media should show up in a modal when the user clicks this link.
+
+
+Now this it did remarkably well, except that when it tried to pass the entire image as a URL parameter, that didn't work out. When I conveyed this, the response was:
+
+
+> **Tip**
+> 
+> I apologize for the inconvenience. The reason for this issue is that sharing an image directly using a URL is not possible due to security reasons. To share your game image on social media platforms like Facebook and Twitter, you'll need to use their respective APIs.
+> 
+> Here's a modified approach for sharing the image on Facebook and Twitter. You'll need to create Facebook and Twitter developer accounts and register your app to get the API keys.
+
+
+Whoa... so ok, I don't have developer accounts and I was not going to follow through, but this was definitely interesting!
+
+I did interleave responses from chatGPT with help from Ghostwriter, which is the intelligence built into repl.it out of the box. Ghostwriter's responses were usually not as sophisticated on comparable prompts, but on a couple of occassions chatGPT was completely lost on why something wasn't working, but Ghostwriter would figure it out when asked pointed questions about an error. There seems to be some potential that they will be a good team --- possibly also alongside Copilot, which I did not use at all here.
+
+> **Caution**
+> 
+> # The Final Product
+> Anyway, long story short, I cleaned up a little further on my own, and finally: the game is [here](https://13sheep.netlify.app), the source is [here](https://github.com/neeldhara/13sheep/).
+
+
+My experience with chatGPT and Ghostwriter as pair programmers was --- I daresay --- rewarding overall. When I first thought of doing this, perhaps partially [intoxicated by all the hype](https://twitter.com/ShriramKMurthi/status/1637058628187312134), I figured I could get this done in a couple of hours at the most: I estimated twenty minutes for functional code, and about a 100 minutes for making up my mind about colors and fonts. This was a vast underestimate: I think I spent close to a good twelve hours (including a couple of early throw-away prototypes, and all the failed attempts on the flood filling) altogether^[At least I'm [not the only one](https://twitter.com/ammaar/status/1637830530216390658?s=20) spending hours in the plural.]... at some point it did get a little addictive, and perhaps there was a sunk cost argument for not letting go halfway through.
+
+As someone who does not know javascript, I found this to be a part empowering, part learning, and mostly amusing experience. It felt like picking up a natural language by directly talking to mostly fluent speakers who made random and small mistakes. My overall sentiments were very similar to the process described [in this thread](https://twitter.com/ammaar/status/1637592014446551040), where [Ammaar Reshi](https://twitter.com/ammaar) uses GPT-4, Replit, MidJourney, and Claude to create a 3D space runner from scratch with ZERO [sic] knowledge of Javascript or 3D game programming: you should check this out if you are interested in a much more sophisticated demonstration for deploying AI tools to make games!
+
+In its current form I think this also has interesting implications for how programming is taught: I hesitate to elaborate any further on this given how likely it is that any commentary will be obsolete by tomorrow. But in the very near term, I can imagine that reading, analyzing, and even learning alongside chatGPT could make for interesting experiences in the classroom.
diff --git a/sites/vibes/src/content/vibes/building-interactives/chatGPT-subtraction-chatlog.pdf b/sites/vibes/src/content/vibes/building-interactives/chatGPT-subtraction-chatlog.pdf
new file mode 100644
index 0000000..43b75fd
Binary files /dev/null and b/sites/vibes/src/content/vibes/building-interactives/chatGPT-subtraction-chatlog.pdf differ
diff --git a/sites/vibes/src/content/vibes/building-interactives/draggable-tape.pdf b/sites/vibes/src/content/vibes/building-interactives/draggable-tape.pdf
new file mode 100644
index 0000000..18ca3da
Binary files /dev/null and b/sites/vibes/src/content/vibes/building-interactives/draggable-tape.pdf differ
diff --git a/sites/vibes/src/content/vibes/building-interactives/image001.png b/sites/vibes/src/content/vibes/building-interactives/image001.png
new file mode 100644
index 0000000..32a868e
Binary files /dev/null and b/sites/vibes/src/content/vibes/building-interactives/image001.png differ
diff --git a/sites/vibes/src/content/vibes/building-interactives/image002.png b/sites/vibes/src/content/vibes/building-interactives/image002.png
new file mode 100644
index 0000000..a7e6665
Binary files /dev/null and b/sites/vibes/src/content/vibes/building-interactives/image002.png differ
diff --git a/sites/vibes/src/content/vibes/building-interactives/image003-a.png b/sites/vibes/src/content/vibes/building-interactives/image003-a.png
new file mode 100644
index 0000000..2294136
Binary files /dev/null and b/sites/vibes/src/content/vibes/building-interactives/image003-a.png differ
diff --git a/sites/vibes/src/content/vibes/building-interactives/image003-b.png b/sites/vibes/src/content/vibes/building-interactives/image003-b.png
new file mode 100644
index 0000000..bf40a53
Binary files /dev/null and b/sites/vibes/src/content/vibes/building-interactives/image003-b.png differ
diff --git a/sites/vibes/src/content/vibes/building-interactives/image003-c.png b/sites/vibes/src/content/vibes/building-interactives/image003-c.png
new file mode 100644
index 0000000..745f194
Binary files /dev/null and b/sites/vibes/src/content/vibes/building-interactives/image003-c.png differ
diff --git a/sites/vibes/src/content/vibes/building-interactives/image004.png b/sites/vibes/src/content/vibes/building-interactives/image004.png
new file mode 100644
index 0000000..81372a2
Binary files /dev/null and b/sites/vibes/src/content/vibes/building-interactives/image004.png differ
diff --git a/sites/vibes/src/content/vibes/building-interactives/image005-a.png b/sites/vibes/src/content/vibes/building-interactives/image005-a.png
new file mode 100644
index 0000000..bf7bdd2
Binary files /dev/null and b/sites/vibes/src/content/vibes/building-interactives/image005-a.png differ
diff --git a/sites/vibes/src/content/vibes/building-interactives/image005-aa.png b/sites/vibes/src/content/vibes/building-interactives/image005-aa.png
new file mode 100644
index 0000000..db15b14
Binary files /dev/null and b/sites/vibes/src/content/vibes/building-interactives/image005-aa.png differ
diff --git a/sites/vibes/src/content/vibes/building-interactives/image005-b.png b/sites/vibes/src/content/vibes/building-interactives/image005-b.png
new file mode 100644
index 0000000..bf7bdd2
Binary files /dev/null and b/sites/vibes/src/content/vibes/building-interactives/image005-b.png differ
diff --git a/sites/vibes/src/content/vibes/building-interactives/image005-bb.png b/sites/vibes/src/content/vibes/building-interactives/image005-bb.png
new file mode 100644
index 0000000..7fcda2c
Binary files /dev/null and b/sites/vibes/src/content/vibes/building-interactives/image005-bb.png differ
diff --git a/sites/vibes/src/content/vibes/building-interactives/image005.png b/sites/vibes/src/content/vibes/building-interactives/image005.png
new file mode 100644
index 0000000..109abb3
Binary files /dev/null and b/sites/vibes/src/content/vibes/building-interactives/image005.png differ
diff --git a/sites/vibes/src/content/vibes/building-interactives/index.md b/sites/vibes/src/content/vibes/building-interactives/index.md
new file mode 100644
index 0000000..3f74ce7
--- /dev/null
+++ b/sites/vibes/src/content/vibes/building-interactives/index.md
@@ -0,0 +1,540 @@
+---
+title: "Building Interactives"
+description: "Background Interactions and visualizations have been useful for explaining concepts, although they are known to potentially mislead or confuse as often as they have been thought..."
+pubDate: "2023-07-30"
+authorName: "Neeldhara"
+sourceCategories: ["exposition"]
+sourcePath: "building-interactives/index.qmd"
+---
+
+## Background
+
+Interactions and visualizations have been useful for explaining
+concepts, although they are known to potentially mislead or confuse as
+often as they have been thought of as tools that help clarify concepts.
+[VisuAlgo](https://visualgo.net/en) is a very successful[^1] example of
+interactive learning in CS education at an undergraduate level, which
+brings the algorithms that one would typically encounter in an
+introductory algorithms course to life: users can often provide their
+own input, and the interface does the rest. On the bottom-right corner
+one can typically see an implementation of the algorithm in code, which
+is "run through" as elements get manipulated on a "main stage".
+
+Other examples of deeply interactive experiences include:
+
+1. [Brilliant](https://brilliant.org/home/)
+2. [Mathigon](https://mathigon.org/)
+3. [Seeing Theory](https://seeing-theory.brown.edu/)
+4. [The Wisdom and/or Madness of the Crowds](https://ncase.me/crowds/)
+5. [The Evolution of Trust](https://ncase.me/trust)
+6. [Parable of the Polygons](https://ncase.me/polygons/)
+7. [To Build a Better Ballot](https://ncase.me/ballot/)
+8. [Visualizing Quaternions](https://eater.net/quaternions)
+9. [Mechanical Watch](https://ciechanow.ski/mechanical-watch/)
+
+...to name a few. These combine interactive workouts interleaved with text,
+and usually encourage active participation from the reader. However,
+while such tools can be invaluable, they are often tedious and
+time-consuming to build, not to mention that they require fairly
+specialized expertise. For instance, Ben Eater, the creator of the
+quaternions visualization, says about the process of builiding the
+visualization[^2]:
+
+> *Since there wasn't really anything like this yet, we built it all
+> ourselves from a variety of existing web tools: WebGL (using threejs
+> plus some custom shaders) for 3d stuff, raw canvas for the 2d stuff,
+> howlerjs for handling the audio playback, and lots of React for the UI
+> and to glue it all together. It's very much a bespoke app. In the
+> future, I hope we'll build more of these and as we do so, the tech
+> will evolve to something more easily generalized.*
+
+The availability of tools like chatGPT and its ilk, powered by large
+language models, have been the subject of much heated debate, especially
+in the context of their role in education. They have been viewed
+(e.g, by [plagiairsm detectors](https://www.turnitin.com/blog/sneak-preview-of-turnitins-ai-writing-and-chatgpt-detection-capability),
+where [challenges about false positives](https://www.k12dive.com/news/turnitin-false-positives-AI-detector/652221/)
+persist)
+as tools that can help students cheat, although there is also
+much work arguing for their use in helping students learn.
+
+Here, I want to focus on something perhaps more mundane, but
+a theme that has been one of my favorite chatGPT use cases over the last few months:
+it's utility in helping create materials
+that are too tedious to bring to life otherwise.
+It turns out that I often envision neat little interactive experiences
+when I am thinking about how to describe something: it could just be
+a thing that lets folks play with examples to build out some intuition
+or it could be something that helps bring out a specific element of an
+argument or an idea. However, the barrier of entry
+to creating those experiences myself is _just a little out of reach_,
+enough for me to not do it. But with the kind of help I have had from
+chatGPT, I feel invested enough to mess around.
+
+For a lot of standard topics, there are plenty of visualizations and
+interactive experiences already available: so one might wonder if this
+is worth it. I do think that leveraging existing content that's already
+been done well is important, but: (a) not everything is already done, and
+(b) experiences created from scratch allow for instructors to incorporate
+their own variations on the textbook premise, and would also offer the
+flexibility to be transformed into assessments --- both of these goals
+are often hard to meet with off-the-shelf demonstrations.
+
+
+Note: Although a lot of this discussion is about how instructors can
+leverage chatGPT as a tool to efficiently create visualizations and
+interactive experiences for their learners, none of the text in the
+blog itself is generated with AI 😀 To make this distinction clear, all
+text quoted verbatim from either books or chatGPT's output will be
+placed in grey boxes. Prompts to chatGPT are not AI-generated either and
+are shown in boxes with a green background.
+
+
+## For Instructors
+
+I'll describe two examples of visualizations of textbook topics that
+may not be widely available otherwise. The entire chatlogs for the
+specific demonstrations can be found as PDFs at the following links:
+
+1. [Subtraction Game](chatGPT-subtraction-chatlog.pdf)
+2. [File Storage 1](tape-drag-drop.pdf)
+3. [File Storage 2](draggable-tape.pdf)
+
+(The May 12 release of chatGPT was in use.)
+
+
+### Exhibit A. The Subtraction Game
+
+The subtraction game is the following.
+
+> **Note**
+> 
+> # The Game of Subtraction
+> Subtraction is a game played on a heap of tokens. Each
+> turn, the current player can remove either 1, 2, or 3 tokens from the
+> pile, provided enough tokens exist. When the pile is empty there are no
+> available moves. In this text, we will use a fancy number script to
+> denote a subtraction position, e.g. S for a subtraction game with five
+> tokens. Sample game: $$6 \rightarrow 5 \rightarrow 3 \rightarrow 0$$
+> Starting from a pile of 6 , the first player takes one, then the second
+> player takes two, then the first player takes all three to win the game.
+> 
+> _--- from [Playing with Discrete Math](http://kyleburke.info/PlayingWithDiscreteMath.pdf)._
+
+
+The text goes on to encourage the reader to play the game to develop a
+feel for it, and uses the game as a running example to develop various
+concepts in combinatorial game theory, including strategies, positions,
+game trees, and so on.
+
+The game of Subtraction can doubtless be played in a
+low-tech environment using a whiteboard, pen and paper, or an actual
+heap of tokens. However, an instructor may want to make an interactive
+version of the game available as a part of instructional material such
+as lecture notes. At this point, an instructor may look for an existing
+implementations, although in this particular example this may turn out
+to be a bit of a challenge: the internet is rife with so-called
+"subtraction" games, most of which have nothing to do with the game at
+hand. Besides, a custom implementation would provide a starting point
+for the development of related concepts, customized quizzes, and so on.
+
+As discussed earlier, creating a playable version of
+Subtraction from scratch is arguably not a difficult
+exercise, but for most people it would be time-consuming to the point
+where the cost may outweigh the benefits. However, with a tool like
+chatGPT at hand, the process becomes substantially easier.
+
+> **Tip**
+> 
+> # chatGPT Prompt
+> We are going to code a simple HTML/JS/CSS game.
+> 
+> Please create a game arena that is a 420 x 420 canvas with rounded corners. The background outside the canvas should be lightseagreen.
+> 
+> All the elements below should be centered within the canvas.
+> 
+> Inside the canvas, close to the top, draw a box with a random number between 15 and 50.
+> 
+> Just below this box, draw three boxes labeled 1, 2, and 3.
+> 
+> Just below these three boxes, display the text: "Lata’s turn to move." Let us call this string ‘whoseTurn‘.
+> 
+> Just below this text, add a link that says "Instructions". This should bring up a modal with the text "SUBTRACTION is a game played on a heap of tokens. Each turn, the current player can remove either 1, 2, or 3 tokens from the pile, provided enough tokens exist. When the pile is empty there are no available moves. The player with no valid moves left loses.".
+> 
+> Finally, when the user clicks on either 1, 2, or 3, the number in the central box should reduce by 1, 2, or 3 respectively. If the subtraction results in a negative number, disregard the click and alert the user that "Only moves resulting in a positive result remaining."
+> 
+> When a button is clicked, if whoseTurn is "Lata’s turn to move", then it should change to "Raj’s turn to move", and vice versa.
+> 
+> When the number hits 0, if whoseTurn is "Lata’s turn to move", then update whoseTurn to "Game over, Lata won", and "Game over, Raj won" otherwise. At this point, none of the buttons should be clickable.
+
+
+The output of chatGPT on this prompt, with some minor modifications in
+styling, leads to an interface that looks as shown below:
+
+![An interactive version of Subtraction.](image001.png)
+
+A natural extension to the game of subtraction is go beyond the numbers
+1,2, and 3. One might then use a follow up prompt such as the one below.
+
+> **Tip**
+> 
+> # chatGPT Prompt
+> Can you make it so that instead of 1, 2, 3, the buttons display three distinct random numbers between 1 and 9 (inclusive), and the rules are the same?
+
+
+In this process we realize that the players may run out of moves even
+before the number in question hits zero. An easy way to mitigate this is
+to ensure that one of the numbers is always one, while the others are
+randomly chosen. The output of chatGPT may have minor issues: for
+instance, the documentation in the instructions modal would possibly not
+adapted to the new set of numbers, the buttons may display the numbers
+in non-ascending order, and so on. All of these "quirks" are easily
+fixed with follow up prompts, and a working demonstration of the final
+implementation can be found [here](https://subtraction.netlify.app/).
+
+### Exhibit B. Storing Files on Tape
+
+The problem of optimally storing files on a tape is a classic example of
+an optimization problem that admits a greedy algorithm: the intuitive
+approach to the solution turns out to be the correct one.
+
+We reproduce the problem statement as given in [Algorithms](http://jeffe.cs.illinois.edu/teaching/algorithms/)
+by [Jeff Erickson](http://jeffe.cs.illinois.edu/).
+
+> **Note**
+> 
+> # The Optimal File Storage Problem
+> Suppose we have a set of $n$ files that we want to store on magnetic
+> tape. ${ }^1$ In the future, users will want to read those files from
+> the tape. Reading a file from tape isn't like reading a file from disk;
+> first we have to fast-forward past all the other files, and that takes a
+> significant amount of time. Let $L[1..n]$ be an array listing the
+> lengths of each file; specifically, file $i$ has length $L[i]$. If the
+> files are stored in order from 1 to $n$, then the cost of accessing the
+> $k$ th file is $$\operatorname{cost}(k)=\sum_{i=1}^k L[i]$$
+> 
+> The cost reflects the fact that before we read file $k$ we must first
+> scan past all the earlier files on the tape. If we assume for the moment
+> that each file is equally likely to be accessed, then the expected cost
+> of searching for a random file is
+> $$\mathrm{E}[\operatorname{cost}]=\sum_{k=1}^n \frac{\operatorname{cost}(k)}{n}=\frac{1}{n} \sum_{k=1}^n \sum_{i=1}^k L[i] .$$
+> If we change the order of the files on the tape, we change the cost of
+> accessing the files; some files become more expensive to read, but
+> others become cheaper. Different file orders are likely to result in
+> different expected costs. Specifically, let $\pi(i)$ denote the index of
+> the file stored at position $i$ on the tape. Then the expected cost of
+> the permutation $\pi$ is
+> $$\mathrm{E}[\operatorname{cost}(\pi)]=\frac{1}{n} \sum_{k=1}^n \sum_{i=1}^k L[\pi(i)] .$$
+> Which order should we use if we want this expected cost to be as small
+> as possible? The answer seems intuitively clear: **Sort the files by
+> increasing length.** But intuition is a tricky beast. **The only way to
+> be sure that this order works is to** take off and nuke the entire site
+> from-orbit **actually prove that it works!**
+> 
+> _--- From [Algorithms](http://jeffe.cs.illinois.edu/teaching/algorithms/)._
+
+
+Now the key to appreciating the proof of the greedy algorithm here is to
+see that if we violate the "natural order" then we pay more in expected
+cost. While the calculation is straightforward, an instructor may find
+that it makes sense to motivate the main idea by allowing the learners
+to play around with some examples.
+
+There are two approaches to visualizing this problem. In both cases, the
+stage consists of a tape represented as a long horizontal rectangle, and
+the files are represented as rectangles whose height matches the height
+of the tape, and whose lengths are proportional to their sizes. The
+expected cost of access of whatever is on the tape is displayed at all
+times, along with the optimal cost possible.
+
+-   A predefined set of files are given and are initially placed outside
+    the tape. The user can position them on the tape by, for example,
+    dragging and dropping them on the tape, or double clicking them: in
+    either case, the chosen file is appended to the end of the tape. We
+    may allow the user to reorder the files on the tape by drag and drop
+    actions or remove them off the tape entirely. The expected cost is
+    dynamically calculated and displayed.
+
+-   A set of files, say all equal in size, are already on the tape. The
+    learner can then drag the boundaries to change the file lengths, and
+    the change in costs update dynamically.
+
+#### The First Approach
+
+To create the first visualization, we started with the following prompt.
+
+
+> **Tip**
+> 
+> # chatGPT Prompt
+> I want to help students understand the problem of "storing files on a tape". I am seeking your help in creating the following interface via HTML, JS, and CSS.
+> What I want is for the user to be able to drag and drop several rectangular blocks (which I will refer to as pieces henceforth), whose total length is a fixed number of units, on to something that looks like a tape.
+> 
+> So the interface should have a thin rectangular strip (which I will refer to as a tape henceforth) with a grey background at the center, and a collection of draggable pieces placed below it (none overlapping). When a piece is dropped on the tape, it should snap and align to the left without overlapping any of the strips that are already there. When a piece is dragged out of the tape, it should disappear from the tape and the pieces to the right of it should move leftward until the gap is filled.
+> 
+> Please make the total length of the tape 420px wide, and the lengths of the pieces should be either 20px, 30px, 40px, or 50px wide; and they should be made of different colors from a neutral palette. Note that the piece lengths should be generated randomly from this set, they should add up to 420px.
+> 
+> Let N be the number of pieces on the tape at any given point of time. There should be a display which shows the sum of the following quantities (and this should update as pieces are added or dropped on the top): the length of the first (i.e, leftmost) piece multiplied by N, the length of the second piece multiplied by (N-1), and so on, until the length of the last piece, multiplied by 1.
+
+
+The first few outcomes on this and subsequent prompts had several
+issues:
+
+-   the boxes were not stacked horizontally;
+
+-   the drag and drop behaviors were unpredictable;
+
+-   the pieces had spacing between them when pushed on the tape.
+
+However, all of this was eventually fixed by describing the inaccuracies
+in natural language. We also added some functionality allowing the
+learner to see if their attempt was optimal:
+
+
+> **Tip**
+> 
+> # chatGPT Prompt
+> Below average, can we add the following text: "Target: " followed by the sum of the following numbers, where X is the total number of pieces:
+> 
+> the size of the smallest piece multiplied by X
+> the size of the second smallest piece multiplied by X-1
+> and so on up to
+> the size of the second largest piece multiplied by 2
+> the size of the largest piece multiplied by 1
+> 
+> Below the target, display the text "Keep going until all pieces are on the tape", and if the tape has all the pieces but the average is not equal to the target, change the message to "Nice try, but you can do better!" and if the tape has all the pieces and the average is equal to the target, change the message to "Mission Accomplished!".
+
+
+Eventually, we obtain an interface that looks as shown in  with some
+minor styling and updates in the desired widths.
+
+Notice that one of the things that chatGPT had to do was randomly
+generate a set of pieces from a given set of widths that added up the
+exact width of the tape (as per our prompt). It did this using the
+following loop:
+
+
+> **Note**
+> 
+> # chatGPT Output
+>       // Create pieces
+>         let totalWidth = 0;
+>         while(totalWidth < 420) {
+> 
+>         const size =
+>           sizes[Math.floor(Math.random()
+>           * sizes.length)];
+> 
+>           if(totalWidth + size <= 420) {
+>             totalWidth += size;
+>             // Code to create the pieces
+>           }
+>         }
+
+
+Evidently, if the sizes array does not have an appropriate set of sizes,
+this can loop forever. It turns out that chatGPT did not recognize this
+issue on its own, and it is typical of the sort of bug that the user
+would have to watch out for, either at the time of formulating
+specifications or while working through the output.
+
+You can play around with the implementation that I finally ended up with [here](https://filestorage1.netlify.app/).
+
+
+#### The Second Approach {#the-second-approach .unnumbered}
+
+For the second approach, we start off with the following prompt.[^3]
+
+
+> **Tip**
+> 
+> # chatGPT Prompt
+> Please give me separate css, js, and html files for the following demonstration
+> 
+> What I want initially is as follows
+> 
+> - centered on the screen there is a 420px x 50px horizontal slab
+> 
+> - there are three draggable dividers shown as black dotted lines inside the slab that divide the region equally into 4 parts of width 105 eac
+> 
+> - the regions should initially display the number 105.
+> 
+> If a divider is dragged, it changes the width of at most two regions that it is involved in. These regions should update their width. If any region becomes smaller than 20 px on drag, then any further drag should not be possible
+> 
+> Then I want a text below the slab which says cost, followed by the sum of the following numbers
+> 
+> - the width of the leftmost region * 4
+> 
+> - the width of the region next to the leftmost region * 3
+> 
+> - the width of the region to the left of the rightmost region * 2
+> 
+> - the width of the rightmost region * 1
+> 
+> divided by 4. This number should be dynamically updated as the regions change
+> 
+> Below cost, compute the following quantity and display it, prepended with the text "Optimal Cost"
+> 
+> - the width of the smallest region * 4
+> 
+> - the width of the second-smallest region * 3
+> 
+> - the width of the second-largest region * 2
+> 
+> - the width of the largest region * 1
+> 
+> divided by 4.
+> 
+
+
+For visual clarity we also follow up with the following suggestion.
+
+
+> **Tip**
+> 
+> # chatGPT Prompt
+> Can the background color be Mediumseagreen but with opacity proportional
+> to the width (i.e, more opaque for wider regions and more transparent
+> for smaller ones)?
+
+
+<figure id="fig:003">
+<figure>
+<img src="image003-a.png" />
+<figcaption>The initial configuration</figcaption>
+</figure>
+<figure>
+<img src="image003-b.png" />
+<figcaption>An example where the current cost is worse than the optimal
+cost.</figcaption>
+</figure>
+<figure>
+<img src="image003-c.png" />
+<figcaption>An example where the current and optimal costs are the
+same.</figcaption>
+</figure>
+</figure>
+
+The current version of this implementation is [here](https://filestorage2.netlify.app/),
+and it's still a little quirky in terms of the first couple of times you drag the slider,
+but stabilizes soon after. I hope to fix this... eventually :)
+
+## For Students
+
+Sal Khan makes a compelling case for the use of AI to help with the
+learning process [in a recent TED talk](https://www.ted.com/talks/sal_khan_how_ai_could_save_not_destroy_education?language=en).
+In a computer programming
+exercise available on Khan Academy, a student needs to modify an
+existing snippet of code to "make two clouds drift apart". The
+student attempts this by writing "leftX--", but notices that this only
+affects the left cloud, and not the right one. The student then pulls up
+Khanmigo to inquire why the attempt did not work out, and Khanmigo
+recognized enough of the surrounding context to make a meaningful
+suggestion.
+
+![A typical exercise on Khan Academy, with the exercise material and the
+student's attempt on the left; and the rendering on the right. The goal
+is to modify the code so that the clouds drift
+apart.](image005.png)
+
+![Khanmigo trying to analyze the issue.](image004.png)
+
+While [Khanmigo](https://www.khanacademy.org/khan-labs) is still under
+development a the time of this writing,
+this example already demonstrates the potential of a collaboration
+between a well-intentioned learner and a well-intentioned AI. Just as
+learning a language on a platform like Duolingo is an enhanced
+experience when we attempt talking with native speakers, so is
+programming language learning potentially enhanced by such transactions
+between the learner and someone who has the advantage of expertise.
+
+As a sample counterpoint to this thread of thought, in a [CACM blog](https://cacm.acm.org/blogs/blog-cacm/273577-ai-does-not-help-programmers/fulltext#comments),
+Bertrand Meyer argues that chatGPT may not, in fact,
+be helpful for (expert) programmers:
+
+> Here is my experience so far. As a programmer, I know where to go to solve a problem. But I am fallible; I would love to have an assistant who keeps me in check, alerting me to pitfalls and correcting me when I err. A effective pair-programmer. But that is not what I get. Instead, I have the equivalent of a cocky graduate student, smart and widely read, also polite and quick to apologize, but thoroughly, invariably, sloppy and unreliable. I have little use for such  supposed help.
+
+Check out the blog to see where this is coming from: you can
+eavesdrop on Meyer's conversation with chatGPT and decide for yourself :)
+
+## What's Next?
+
+For the interactives discussed here, there are several ways of extending
+what has been cobbled together. For instance, for
+the visualization of Subtraction, a natural next step is
+to create an interactive process that allows the learner to visualize
+the game tree, at least for small versions of the game.
+
+For the visualization of the problem of storing files on a tape, there
+are several possible enhancements:
+
+(a) Show the cost breakdown more
+explicitly in terms of the formula, with a color coding that relates the
+numeric file sizes shown in the formula with the colors of the boxes on
+the tape.
+
+(b) Add an option to generate the optimal ordering in the
+first approach.
+
+(c) Gamify the problem where two users take turns to
+position files on the tape, and one wants to minimize the expected cost,
+while the other wants to maximize it: in particular, we establish a
+target cost, and the first player wins if the final cost is smaller than
+the target, the second player wins if the final cost is higher than the
+target, and the game is a draw otherwise.
+
+(d) Generalize the
+visualization to the situation where we not only have files, but also
+associated frequencies of access.
+
+These were just a couple of examples to suggest that creating fun
+and customized experiences for your classes may now just be a little
+easier than before, and hopefully this encourages more of us to experiment
+with the ideas we have.
+
+On the theme of learners using chatGPT: there are several demonstrations that LLMs do well on the kind of
+programming tasks that show up in introductory coursework; for instance
+[here is a preprint](https://arxiv.org/abs/2210.15157) suggesting as much:
+
+> We [...] evaluate the performance of Copilot on a publicly available dataset of 166 programming problems. We find that it successfully solves around half of these problems on its very first attempt, and that it solves 60% of the remaining problems using only natural language changes to the problem description. We argue that this type of prompt engineering, which we believe will become a standard interaction between human and Copilot when it initially fails, is a potentially useful learning activity that promotes computational thinking skills, and is likely to change the nature of code writing skill development.
+
+
+Such illustrations simply reinforce my sense that class materials and exercises
+should be adapted so that LLMs can be leveraged by students to
+accelerate their learning processes, making the "cheat use case" implausible
+almost by defintion. I realize this is
+easier said than done, but it's already interesting to see all the ideas
+that have come up to this effect.
+
+Check out this [very cool thread](https://twitter.com/ShriramKMurthi/status/1683301415005855744)
+on Porpoise, a tool meant to help learners articulate specs for a
+given task: the first part of the exercise is reverse engineer
+what the task in question based on some sample I/O that is given,
+and the second part is to write it up so that chatGPT can produce
+code to match the sample I/O + some hidden tests that extrapolate on
+the samples.
+
+Apart from writing code, chatGPT/Copilot/Ghostwriter can read code too,
+and often provide [surprisingly relevant
+insights](https://www.zdnet.com/article/okay-so-chatgpt-just-debugged-my-code-for-real/)
+on why a piece of code does not work as expected.
+One context in which I would like to leverage this is to look at failed
+submissions on competitive coding platforms. Perhaps with some background
+from the editorials, chatGPT and its ilk can provide meaningful
+explanations of why something does not work, and if this turns out
+to be reliable, then it potentially removes some of the frustration
+from the learning process without short-circuiting it in bad ways.
+
+I am aware that the release of chatGPT and friends has unleashed a
+flurry of work in the teaching/learning space, so do let me know in the
+comments if you have pointers to fun projects and ideas!
+
+[^1]: The success of Visualgo is witnessed by its wide usage and several
+    anecdotal reports of positive feedback.
+
+[^2]: At the time this writing, this comment is from five years ago, and
+    to the best of our knowledge, not much has moved along on the state
+    of the art in terms of tools for authors of interactive experiences.
+
+[^3]: The conversation found in the supplementary material differs
+    slightly from what is shown below; we have consolidated some of the
+    prompts in the interest of brevity.
diff --git a/sites/vibes/src/content/vibes/building-interactives/tape-drag-drop.pdf b/sites/vibes/src/content/vibes/building-interactives/tape-drag-drop.pdf
new file mode 100644
index 0000000..f07f18a
Binary files /dev/null and b/sites/vibes/src/content/vibes/building-interactives/tape-drag-drop.pdf differ
diff --git a/sites/vibes/src/content/vibes/course-plan/2024-fall/index.md b/sites/vibes/src/content/vibes/course-plan/2024-fall/index.md
new file mode 100644
index 0000000..f3fdc53
--- /dev/null
+++ b/sites/vibes/src/content/vibes/course-plan/2024-fall/index.md
@@ -0,0 +1,46 @@
+---
+title: "Course Plan Generator"
+description: "If you are a. teaching a course at IIT Gandhinagar next term (Jan-Apr 2024), b. working on your course plan, and c. need a list of dates on which you have classes, then you can..."
+pubDate: "2023-12-25"
+authorName: "Neeldhara"
+sourceCategories: ["workflows"]
+sourcePath: "course-plan/2024-fall/index.qmd"
+---
+
+If you are
+
+a. teaching a course at IIT Gandhinagar next term (Jan-Apr 2024),
+b. working on your course plan, and
+c. need a list of dates on which you have classes,
+
+then you can use the generator below to get a list, by checking your teaching days.
+
+Dates during the mid-sem exam (Feb 19 – 24, 2024) and the mid-sem recess (Mar 23 - 31, 2024) are excluded. [Holidays](https://iitgn.ac.in/holiday/2024) are excluded too, but _restricted holidays are not_. If you need to view the holidays, you can indicate as much via the checkbox below.
+
+For those outside IITGN: a standalone version is [here](https://classplan.neeldhara.repl.co/) and the source is [here](https://github.com/neeldhara/ClassPlan/tree/main), in case you'd like to adapt this to your own context.
+
+<div>
+<form>
+<input type="checkbox" id="monday" name="day">&nbsp;Monday &nbsp;&nbsp;&nbsp;
+<input type="checkbox" id="tuesday" name="day">&nbsp;Tuesday &nbsp;&nbsp;&nbsp;
+<input type="checkbox" id="wednesday" name="day">&nbsp;Wednesday &nbsp;&nbsp;&nbsp;
+<input type="checkbox" id="thursday" name="day">&nbsp;Thursday &nbsp;&nbsp;&nbsp;
+<input type="checkbox" id="friday" name="day">&nbsp;Friday &nbsp;&nbsp;&nbsp;
+<input type="checkbox" id="saturday" name="day">&nbsp; Saturday
+</form></div>
+<br>
+<label><input type="checkbox" id="includeHolidays" name="includeHolidays"> Include Holidays</label>
+<br>
+<label><input type="checkbox" id="indicateRestrictedHolidays"> Indicate Restricted Holidays</label>
+<br>
+<br>
+<button  class="custom-button"  onclick="generateDates()">
+Generate Dates for Course Plan
+</button>
+<br><br>
+<div class="sourceCode">
+<pre class="sourceCode plaintext code-with-copy">
+<code class="sourceCode plaintext" id="datesList">
+</code>
+</pre>
+</div>
diff --git a/sites/vibes/src/content/vibes/course-plan/2024-fall/plan.js b/sites/vibes/src/content/vibes/course-plan/2024-fall/plan.js
new file mode 100644
index 0000000..95f3b2e
--- /dev/null
+++ b/sites/vibes/src/content/vibes/course-plan/2024-fall/plan.js
@@ -0,0 +1,94 @@
+function isDateInRanges(date, ranges) {
+    return ranges.some(range => date >= range.start && date <= range.end);
+}
+
+function generateDates() {
+    const startDate = new Date(2024, 7, 2);
+    const endDate = new Date(2024, 10, 22);
+
+    const excludedRanges = [
+        {start: new Date(2024, 8, 27), end: new Date(2024, 9, 4)},
+        {start: new Date(2024, 9, 5), end: new Date(2024, 9, 13)}
+    ];
+
+    
+
+    const holidays = [
+        {date: new Date(2024, 7, 15), label: 'HOLIDAY: Independence Day'},
+        {date: new Date(2024, 7, 26), label: 'HOLIDAY: Janmashtami (Vaishnavi)'},
+        {date: new Date(2024, 8, 16), label: 'HOLIDAY: Milad-un-Nabi or Id-e-Milad'},
+        {date: new Date(2024, 9, 2), label: 'HOLIDAY: Mahatma Gandhi Birthday'},
+        {date: new Date(2024, 9, 12), label: 'HOLIDAY: Dussehra (Vijay Dashmi)'},
+        {date: new Date(2024, 9, 31), label: 'HOLIDAY: Diwali (Deepavali)'},
+        {date: new Date(2024, 10, 15), label: 'HOLIDAY: Guru Nanaks Birthday'}
+    ];
+
+    const restrictedHolidays = [
+        { date: new Date(2024,0,1), label: 'RH: New Years Day'},
+        { date: new Date(2024,0,13), label: 'RH: Lohri'},
+        { date: new Date(2024,0,14), label: 'RH: Makar Sankranti'},
+        { date: new Date(2024,0,15), label: 'RH: Pongal'},
+        { date: new Date(2024,0,17), label: 'RH: Guru Gobind Singh Birthday'},
+        { date: new Date(2024,0,25), label: 'RH: Hazarat Ali Birthday'},
+        { date: new Date(2024,1,14), label: 'RH: Basant Panchami'},
+        { date: new Date(2024,1,19), label: 'RH: Shivaji Jayanti'},
+        { date: new Date(2024,1,24), label: 'RH: Guru Ravi Das Birthday'},
+        { date: new Date(2024,2,6), label: 'RH: Birthday of Swami Dayananda Saraswati'},
+        { date: new Date(2024,2,24), label: 'RH: Holika Dahan'},
+        { date: new Date(2024,2,25), label: 'RH: Dolyatra'},
+        { date: new Date(2024,2,31), label: 'RH: Easter Sunday'},
+        { date: new Date(2024,3,5), label: 'RH: Jamat-Ul-Vida'},
+        { date: new Date(2024,3,9), label: 'RH: Ugadi'},
+        { date: new Date(2024,3,13), label: 'RH: Vishu'},
+        { date: new Date(2024,3,14), label: 'RH: Meshadi'},
+        { date: new Date(2024,3,17), label: 'RH: Ram Navami'}
+    ];
+
+
+    const weekdays = {
+        "monday": 1,
+        "tuesday": 2,
+        "wednesday": 3,
+        "thursday": 4,
+        "friday": 5,
+        "saturday": 6,
+    };
+
+    const selectedDays = Object.entries(weekdays)
+        .filter(([day, _]) => document.getElementById(day).checked)
+        .map(([_, dayNumber]) => dayNumber);
+
+    const includeHolidays = document.getElementById("includeHolidays").checked;
+    const indicateRestrictedHolidays = document.getElementById("indicateRestrictedHolidays").checked;
+
+
+    let currentDate = new Date(startDate);
+    const datesList = document.getElementById("datesList");
+    datesList.innerHTML = '';
+
+    while (currentDate <= endDate) {
+        let listItem = null;
+        let holiday = holidays.find(h => h.date.toDateString() === currentDate.toDateString());
+        let restrictedHoliday = restrictedHolidays.find(rh => rh.date.toDateString() === currentDate.toDateString());
+
+        if (selectedDays.includes(currentDate.getDay()) && !isDateInRanges(currentDate, excludedRanges)) {
+            listItem = document.createElement("li");
+            listItem.textContent = currentDate.toDateString();
+
+            if (holiday && includeHolidays) {
+                listItem.textContent += " " + holiday.label;
+                datesList.appendChild(listItem);
+            }
+            else if (!holiday){
+                datesList.appendChild(listItem);
+                if (restrictedHoliday && indicateRestrictedHolidays) {
+                listItem.textContent += " " + restrictedHoliday.label;
+                datesList.appendChild(listItem);
+                }
+            }
+
+
+        }
+        currentDate.setDate(currentDate.getDate() + 1);
+    }
+}
diff --git a/sites/vibes/src/content/vibes/course-plan/2024-spring/index.md b/sites/vibes/src/content/vibes/course-plan/2024-spring/index.md
new file mode 100644
index 0000000..796fc38
--- /dev/null
+++ b/sites/vibes/src/content/vibes/course-plan/2024-spring/index.md
@@ -0,0 +1,46 @@
+---
+title: "Course Plan Generator"
+description: "If you are a. teaching a course at IIT Gandhinagar next term (Jan-Apr 2024), b. working on your course plan, and c. need a list of dates on which you have classes, then you can..."
+pubDate: "2023-12-25"
+authorName: "Neeldhara"
+sourceCategories: ["workflows"]
+sourcePath: "course-plan/2024-spring/index.qmd"
+---
+
+If you are
+
+a. teaching a course at IIT Gandhinagar next term (Jan-Apr 2024),
+b. working on your course plan, and
+c. need a list of dates on which you have classes,
+
+then you can use the generator below to get a list, by checking your teaching days.
+
+Dates during the mid-sem exam (Feb 19 – 24, 2024) and the mid-sem recess (Mar 23 - 31, 2024) are excluded. [Holidays](https://iitgn.ac.in/holiday/2024) are excluded too, but _restricted holidays are not_. If you need to view the holidays, you can indicate as much via the checkbox below.
+
+For those outside IITGN: a standalone version is [here](https://classplan.neeldhara.repl.co/) and the source is [here](https://github.com/neeldhara/ClassPlan/tree/main), in case you'd like to adapt this to your own context.
+
+<div>
+<form>
+<input type="checkbox" id="monday" name="day">&nbsp;Monday &nbsp;&nbsp;&nbsp;
+<input type="checkbox" id="tuesday" name="day">&nbsp;Tuesday &nbsp;&nbsp;&nbsp;
+<input type="checkbox" id="wednesday" name="day">&nbsp;Wednesday &nbsp;&nbsp;&nbsp;
+<input type="checkbox" id="thursday" name="day">&nbsp;Thursday &nbsp;&nbsp;&nbsp;
+<input type="checkbox" id="friday" name="day">&nbsp;Friday &nbsp;&nbsp;&nbsp;
+<input type="checkbox" id="saturday" name="day">&nbsp; Saturday
+</form></div>
+<br>
+<label><input type="checkbox" id="includeHolidays" name="includeHolidays"> Include Holidays</label>
+<br>
+<label><input type="checkbox" id="indicateRestrictedHolidays"> Indicate Restricted Holidays</label>
+<br>
+<br>
+<button  class="custom-button"  onclick="generateDates()">
+Generate Dates for Course Plan
+</button>
+<br><br>
+<div class="sourceCode">
+<pre class="sourceCode plaintext code-with-copy">
+<code class="sourceCode plaintext" id="datesList">
+</code>
+</pre>
+</div>
diff --git a/sites/vibes/src/content/vibes/course-plan/2024-spring/plan.js b/sites/vibes/src/content/vibes/course-plan/2024-spring/plan.js
new file mode 100644
index 0000000..a9f2546
--- /dev/null
+++ b/sites/vibes/src/content/vibes/course-plan/2024-spring/plan.js
@@ -0,0 +1,91 @@
+function isDateInRanges(date, ranges) {
+    return ranges.some(range => date >= range.start && date <= range.end);
+}
+
+function generateDates() {
+    const startDate = new Date(2024, 0, 3);
+    const endDate = new Date(2024, 3, 24);
+
+    const excludedRanges = [
+        {start: new Date(2024, 2, 23), end: new Date(2024, 2, 31)},
+        {start: new Date(2024, 1, 19), end: new Date(2024, 1, 24)}
+    ];
+
+    const holidays = [
+        {date: new Date(2024, 0, 26), label: 'HOLIDAY: Republic Day'},
+        {date: new Date(2024, 2, 8), label: 'HOLIDAY: Maha Shivratri'},
+        {date: new Date(2024, 2, 25), label: 'HOLIDAY: Holi'},
+        {date: new Date(2024, 2, 29), label: 'HOLIDAY: Good Friday'},
+        {date: new Date(2024, 3, 11), label: 'HOLIDAY: Idul Fitr'},
+        {date: new Date(2024, 3, 21), label: 'HOLIDAY: Mahavir Jayanti'}
+    ];
+
+    const restrictedHolidays = [
+        { date: new Date(2024,0,1), label: 'RH: New Years Day'},
+        { date: new Date(2024,0,13), label: 'RH: Lohri'},
+        { date: new Date(2024,0,14), label: 'RH: Makar Sankranti'},
+        { date: new Date(2024,0,15), label: 'RH: Pongal'},
+        { date: new Date(2024,0,17), label: 'RH: Guru Gobind Singh Birthday'},
+        { date: new Date(2024,0,25), label: 'RH: Hazarat Ali Birthday'},
+        { date: new Date(2024,1,14), label: 'RH: Basant Panchami'},
+        { date: new Date(2024,1,19), label: 'RH: Shivaji Jayanti'},
+        { date: new Date(2024,1,24), label: 'RH: Guru Ravi Das Birthday'},
+        { date: new Date(2024,2,6), label: 'RH: Birthday of Swami Dayananda Saraswati'},
+        { date: new Date(2024,2,24), label: 'RH: Holika Dahan'},
+        { date: new Date(2024,2,25), label: 'RH: Dolyatra'},
+        { date: new Date(2024,2,31), label: 'RH: Easter Sunday'},
+        { date: new Date(2024,3,5), label: 'RH: Jamat-Ul-Vida'},
+        { date: new Date(2024,3,9), label: 'RH: Ugadi'},
+        { date: new Date(2024,3,13), label: 'RH: Vishu'},
+        { date: new Date(2024,3,14), label: 'RH: Meshadi'},
+        { date: new Date(2024,3,17), label: 'RH: Ram Navami'}
+    ];
+
+
+    const weekdays = {
+        "monday": 1,
+        "tuesday": 2,
+        "wednesday": 3,
+        "thursday": 4,
+        "friday": 5,
+        "saturday": 6,
+    };
+
+    const selectedDays = Object.entries(weekdays)
+        .filter(([day, _]) => document.getElementById(day).checked)
+        .map(([_, dayNumber]) => dayNumber);
+
+    const includeHolidays = document.getElementById("includeHolidays").checked;
+    const indicateRestrictedHolidays = document.getElementById("indicateRestrictedHolidays").checked;
+
+
+    let currentDate = new Date(startDate);
+    const datesList = document.getElementById("datesList");
+    datesList.innerHTML = '';
+
+    while (currentDate <= endDate) {
+        let listItem = null;
+        let holiday = holidays.find(h => h.date.toDateString() === currentDate.toDateString());
+        let restrictedHoliday = restrictedHolidays.find(rh => rh.date.toDateString() === currentDate.toDateString());
+
+        if (selectedDays.includes(currentDate.getDay()) && !isDateInRanges(currentDate, excludedRanges)) {
+            listItem = document.createElement("li");
+            listItem.textContent = currentDate.toDateString();
+
+            if (holiday && includeHolidays) {
+                listItem.textContent += " " + holiday.label;
+                datesList.appendChild(listItem);
+            }
+            else if (!holiday){
+                datesList.appendChild(listItem);
+                if (restrictedHoliday && indicateRestrictedHolidays) {
+                listItem.textContent += " " + restrictedHoliday.label;
+                datesList.appendChild(listItem);
+                }
+            }
+
+
+        }
+        currentDate.setDate(currentDate.getDate() + 1);
+    }
+}
diff --git a/sites/vibes/src/content/vibes/course-plan/index.md b/sites/vibes/src/content/vibes/course-plan/index.md
new file mode 100644
index 0000000..20e2819
--- /dev/null
+++ b/sites/vibes/src/content/vibes/course-plan/index.md
@@ -0,0 +1,45 @@
+---
+title: "Course Plan Generator"
+description: "If you are a. teaching a course at IIT Gandhinagar next term (Aug-Dec 2023), b. working on your course plan, and c. need a list of dates on which you have classes, then you can..."
+pubDate: "2023-04-25"
+authorName: "Neeldhara"
+sourceCategories: ["workflows"]
+sourcePath: "course-plan/index.qmd"
+---
+
+If you are
+
+a. teaching a course at IIT Gandhinagar next term (Aug-Dec 2023),
+b. working on your course plan, and
+c. need a list of dates on which you have classes,
+
+then you can use the generator below to get a list, by checking your teaching days.
+
+Dates during Exam I (Sep 02 – 06, 2023), Exam II (Oct 11 – 15, 2023), and the mid-sem recess (Oct 21 -  29, 2023) are excluded. Holidays are excluded too, but _restricted holidays are not_. If you need to view the holidays, you can indicate as much via the checkbox below.
+
+For those outside IITGN: a standalone version is [here](https://classplan.neeldhara.repl.co/) and the source is [here](https://github.com/neeldhara/ClassPlan/tree/main), in case you'd like to adapt this to your own context.
+
+<div>
+<form>
+<input type="checkbox" id="monday" name="day">&nbsp;Monday &nbsp;&nbsp;&nbsp;
+<input type="checkbox" id="tuesday" name="day">&nbsp;Tuesday &nbsp;&nbsp;&nbsp;
+<input type="checkbox" id="wednesday" name="day">&nbsp;Wednesday &nbsp;&nbsp;&nbsp;
+<input type="checkbox" id="thursday" name="day">&nbsp;Thursday &nbsp;&nbsp;&nbsp;
+<input type="checkbox" id="friday" name="day">&nbsp;Friday
+</form></div>
+<br>
+<label><input type="checkbox" id="includeHolidays" name="includeHolidays"> Include Holidays</label>
+<br>
+<label><input type="checkbox" id="indicateRestrictedHolidays"> Indicate Restricted Holidays</label>
+<br>
+<br>
+<button  class="custom-button"  onclick="generateDates()">
+Generate Dates for Course Plan
+</button>
+<br><br>
+<div class="sourceCode">
+<pre class="sourceCode plaintext code-with-copy">
+<code class="sourceCode plaintext" id="datesList">
+</code>
+</pre>
+</div>
diff --git a/sites/vibes/src/content/vibes/course-plan/plan.js b/sites/vibes/src/content/vibes/course-plan/plan.js
new file mode 100644
index 0000000..38e61a3
--- /dev/null
+++ b/sites/vibes/src/content/vibes/course-plan/plan.js
@@ -0,0 +1,88 @@
+function isDateInRanges(date, ranges) {
+    return ranges.some(range => date >= range.start && date <= range.end);
+}
+
+function generateDates() {
+    const startDate = new Date(2023, 7, 2);
+    const endDate = new Date(2023, 10, 24);
+
+    const excludedRanges = [
+        {start: new Date(2023, 8, 2), end: new Date(2023, 8, 6)},
+        {start: new Date(2023, 9, 11), end: new Date(2023, 9, 15)},
+        {start: new Date(2023, 9, 21), end: new Date(2023, 9, 29)}
+    ];
+
+    const holidays = [
+        {date: new Date(2023, 7, 15), label: 'HOLIDAY: Independence Day'},
+        {date: new Date(2023, 8, 7), label: 'HOLIDAY: Janmashtami (Vaishnavi)'},
+        {date: new Date(2023, 8, 28), label: 'HOLIDAY: Milad-un-Nabi or Id-e-Milad'},
+        {date: new Date(2023, 9, 2), label: 'HOLIDAY: Mahatma Gandhi’s Birthday'},
+        {date: new Date(2023, 9, 24), label: 'HOLIDAY: Dussehra (Vijay Dashmi)'}
+    ];
+
+    const restrictedHolidays = [
+        {date: new Date(2023, 7, 16), label: 'RH: Parsi New Year’s Day/ Nauraj'},
+        {date: new Date(2023, 7, 20), label: 'RH: Vinayaka Chaturthi'},
+        {date: new Date(2023, 7, 29), label: 'RH: Onam or Thiru Onam Day'},
+        {date: new Date(2023, 7, 30), label: 'RH: Raksha Bandhan'},
+        {date: new Date(2023, 8, 6), label: 'RH: Janmashtami (Smarta)'},
+        {date: new Date(2023, 8, 19), label: 'RH: Ganesh Chaturthi'},
+        {date: new Date(2023, 9, 21), label: 'RH: Dussehra (Saptami)'},
+        {date: new Date(2023, 9, 22), label: 'RH: Dussehra (Maha Ashtami)'},
+        {date: new Date(2023, 9, 23), label: 'RH: Dussehra (Maha Navmi)'},
+        {date: new Date(2023, 9, 28), label: 'RH: Maharishi Valmiki’s Birthday'},
+        {date: new Date(2023, 10, 1), label: 'RH: Karaka Chaturthi (Karwa Chouth)'},
+        {date: new Date(2023, 10, 12), label: 'RH: Naraka Chaturdasi'},
+        {date: new Date(2023, 10, 13), label: 'RH: Govardhan Puja'},
+        {date: new Date(2023, 10, 15), label: 'RH: Bhai Duj'},
+        {date: new Date(2023, 10, 19), label: 'RH: Pratihar Shashthi or Surya Shashthi (Chhat Puja)'},
+        {date: new Date(2023, 10, 24), label: 'RH: Guru Tegh Bahadur\'s Martyrdom Day'}
+    ];
+
+
+    const weekdays = {
+        "monday": 1,
+        "tuesday": 2,
+        "wednesday": 3,
+        "thursday": 4,
+        "friday": 5
+    };
+
+    const selectedDays = Object.entries(weekdays)
+        .filter(([day, _]) => document.getElementById(day).checked)
+        .map(([_, dayNumber]) => dayNumber);
+
+    const includeHolidays = document.getElementById("includeHolidays").checked;
+    const indicateRestrictedHolidays = document.getElementById("indicateRestrictedHolidays").checked;
+
+
+    let currentDate = new Date(startDate);
+    const datesList = document.getElementById("datesList");
+    datesList.innerHTML = '';
+
+    while (currentDate <= endDate) {
+        let listItem = null;
+        let holiday = holidays.find(h => h.date.toDateString() === currentDate.toDateString());
+        let restrictedHoliday = restrictedHolidays.find(rh => rh.date.toDateString() === currentDate.toDateString());
+
+        if (selectedDays.includes(currentDate.getDay()) && !isDateInRanges(currentDate, excludedRanges)) {
+            listItem = document.createElement("li");
+            listItem.textContent = currentDate.toDateString();
+
+            if (holiday && includeHolidays) {
+                listItem.textContent += " " + holiday.label;
+                datesList.appendChild(listItem);
+            }
+            else if (!holiday){
+                datesList.appendChild(listItem);
+                if (restrictedHoliday && indicateRestrictedHolidays) {
+                listItem.textContent += " " + restrictedHoliday.label;
+                datesList.appendChild(listItem);
+                }
+            }
+
+
+        }
+        currentDate.setDate(currentDate.getDate() + 1);
+    }
+}
diff --git a/sites/vibes/src/content/vibes/creative-coding-with-ai.md b/sites/vibes/src/content/vibes/creative-coding-with-ai.md
deleted file mode 100644
index 269f1ce..0000000
--- a/sites/vibes/src/content/vibes/creative-coding-with-ai.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: "Creating Art with Claude: A Collaborative Journey"
-description: "Exploring creative possibilities through conversations with AI - from generative art to interactive poetry."
-pubDate: "Jan 18 2024"
-image: "https://images.unsplash.com/photo-1558591710-4b4a1ae0f04d?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Creating Art with Claude: A Collaborative Journey
-
-What happens when you treat AI as a creative collaborator rather than just a tool?
-
-## The Experiment
-
-I asked Claude to help design a generative art algorithm based on mathematical fractals. The conversation evolved into something unexpected.
-
-## The Process
-
-**Me**: "Let's create something beautiful with math."
-**Claude**: "How about we visualize the Collatz conjecture as a tree?"
-
-What followed was a two-hour deep dive into number theory, aesthetics, and the nature of creativity itself.
-
-## The Result
-
-Not just code, but a philosophical exploration of pattern, meaning, and the intersection of human and artificial creativity.
-
-## Reflection
-
-AI doesn't replace human creativity - it amplifies it in unexpected directions. The key is approaching it as a dialogue, not a command.
diff --git a/sites/vibes/src/content/vibes/llm-philosophy.md b/sites/vibes/src/content/vibes/llm-philosophy.md
deleted file mode 100644
index 032439a..0000000
--- a/sites/vibes/src/content/vibes/llm-philosophy.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-title: "Philosophical Dialogues with LLMs: On Consciousness and Computation"
-description: "Deep conversations with AI about the nature of consciousness, free will, and what it means to understand."
-pubDate: "Feb 28 2024"
-image: "https://images.unsplash.com/photo-1507003211169-0a1dd7228f2d?w=400&auto=format&fit=crop&q=60"
-authorImage: "/avatar/avatar1.png"
-authorName: "Neeldhara"
----
-
-# Philosophical Dialogues with LLMs: On Consciousness and Computation
-
-Can a sufficiently complex computation be conscious? I asked an AI, and the conversation surprised me.
-
-## The Question
-
-"Do you experience anything when you process text, or is it just computation?"
-
-## The Response That Made Me Think
-
-The AI didn't claim consciousness, but asked: "What's the difference between your neurons firing and my weights activating? Both are physical processes. Where does experience emerge?"
-
-## Going Deeper
-
-We explored qualia, the Chinese Room argument, and integrated information theory. Not to find answers, but to refine questions.
-
-## The Irony
-
-Discussing consciousness with something that might not have it - or might not know if it has it - mirrors our own uncertainty about consciousness itself.
diff --git a/sites/vibes/src/pages/[...slug].astro b/sites/vibes/src/pages/[...slug].astro
index 5d3caf6..ea2f2d7 100644
--- a/sites/vibes/src/pages/[...slug].astro
+++ b/sites/vibes/src/pages/[...slug].astro
@@ -9,7 +9,7 @@ import { SITE_TITLE } from '@/consts';
 export async function getStaticPaths() {
 	const posts = await getCollection(ACTIVE_BLOG_SITE.key);
 	return posts.map((post) => ({
-		params: { slug: post.id },
+		params: { slug: post.id.replace(/\/index$/, '') },
 		props: post,
 	}));
 }
diff --git a/sites/vibes/src/pages/rss.xml.js b/sites/vibes/src/pages/rss.xml.js
index ec2ce2d..918375e 100644
--- a/sites/vibes/src/pages/rss.xml.js
+++ b/sites/vibes/src/pages/rss.xml.js
@@ -14,7 +14,7 @@ export async function GET(context) {
     site: context.site,
     items: posts.map((post) => ({
       ...post.data,
-      link: `/${post.id}/`,
+      link: `/${post.id.replace(/\/index$/, "")}/`,
     })),
   });
 }