DEV Community: Fit Happens ML

Anthropic's Free Credit Window Closes April 17. Don't Miss It.

Fit Happens ML — Sun, 05 Apr 2026 15:26:32 +0000

So here's the good news - Anthropic is once again showing its legendary generosity. Or more precisely, they're giving away free API credits.

If you're on the 5x Max plan, congratulations - you've been awarded $100 in credits you'll burn through in approximately one ambitious afternoon of agentic coding.

The claim window closes April 17, 2026. However, once redeemed, the credits remain active for 90 days - so there's no pressure to burn through them immediately.

Now here's the catch: this isn't an incentive to sign up. The eligibility cutoff was April 3rd - if you weren't already a paying subscriber by then, you're out of luck. Signing up now won't get you in.

And here's the part that worries me: companies don't give away free money without a reason. My bet? Rate limit cuts are coming. The credits are a cushion to soften the blow.

BTW you can clime your credits right on https://claude.ai/settings/usage

AI Wrote Code But You Don't Have npm? Here's What to Do

Fit Happens ML — Wed, 04 Mar 2026 08:55:49 +0000

A practical guide covering the complete installation process through to your first functional project

TL;DR: This guide lays out everything about Node.js and npm in one place. If you're using AI to write code (hello, vibe coders!), you might end up with a project you need to build but no npm installed. Here's what to install, what alternatives you have, what goes wrong and how to fix it + plus some senior dev tips.

IMPORTANT!
If you don't want to install anything and want to build everything in the cloud, you can skip the first part of the article until the Cloud Building heading.

Introduction

Node.js is basically JavaScript running outside the browser — on your computer, a server, whatever.

npm (Node Package Manager) comes with Node.js and lets you:

Grab thousands of libraries off the shelf
Keep track of versions
Run build scripts
Publish your own packages

Methods for Installing Node.js on Windows

The selection of an installation method should be based on what you are doing. For isolated or one-time usage scenarios, the official installer is OK. For ongoing development activities, NVM or Chocolatey are much better.

Installation via Official Installer

Step 1: Downloading

Go to https://nodejs.org/
Download the LTS version (Long Term Support) — it's more stable
Run the .msi installer
Agree to everything.
npm is usually added to PATH automatically
Then you need to verify:

node --version
# Should output: v20.x.x or v18.x.x

npm --version
# Should output: 10.x.x

Why It's Good

Easy peasy... Download LTS, click "Next" a bunch of times — boom, you've got Node.js. Easy if you don't want to mess with setup.

Why It Sucks

Updating means downloading a whole new installer
Can't run different versions side by side
Stuck with what you installed

FOR VIBE CODERS: If AI generated code for a newer version of Node.js and you have an old one — there will be errors.
P.S. NVM solves this problem. Check section Installation via NVM.

Installation via Chocolatey

What's Chocolatey?
Windows package manager. Like apt-get on Linux. Install once, then everything via commands.

What You Need First

Get Chocolatey (if missing):

Run PowerShell as admin:

# Check if choco is installed
choco --version

# If not, install:
Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))

Install Node.js

# Install latest LTS
choco install nodejs-lts -y

# Specific version
choco install nodejs --version=20.11.0 -y

# Update
choco upgrade nodejs-lts

# Uninstall
choco uninstall nodejs

Why It's Good

Big upsides:

Easy updates: choco upgrade nodejs-lts
One command to uninstall
Adds to PATH automatically
Install any program this way

Installation via Winget

Windows 10 (1809+) and Windows 11 have a built-in package manager — Winget. No additional installation needed.

Commands

# Search available versions
winget search nodejs

# Install LTS version
winget install OpenJS.NodeJS.LTS

# Install latest (non-LTS)
winget install OpenJS.NodeJS

# Update
winget upgrade OpenJS.NodeJS.LTS

# Uninstall
winget uninstall OpenJS.NodeJS

Installation via NVM (Recommended for Developers)

NVM (Node Version Manager) is the standard in the Node.js development world. Allows you to have multiple versions of Node.js simultaneously and switch between them with a single command.

Especially useful when:

Old project requires Node.js 16, while new one requires Node.js 20
Testing compatibility across different versions
Gradually updating the version

Option 1: NVM for Windows

Download from: https://github.com/coreybutler/nvm-windows/releases
Install nvm-setup.exe
Open a new terminal

NVM Commands (for Windows)

IMPORTANT! NVM commands for Linux/Mac do not work on Windows. NVM for Windows has different syntax.

IMPORTANT! For the nvm use command to work, the terminal must be run as Administrator, or Developer Mode must be enabled in Windows (Settings -> Privacy & security -> For developers). Otherwise, Windows will block symlink creation and the Node.js version won't switch.

# Install specific version (MUST specify!)
nvm install 20
nvm install 18
nvm install 20.11.0

# Install latest available version (NOT lts!)
nvm install latest

# View installed versions
nvm list

# Use a specific version
nvm use 20

# Note: nvm alias default does NOT work on Windows!
# The version selected via nvm use becomes active automatically

# Uninstall a version
nvm uninstall 18

Option 2: Volta (Modern Alternative)

FOR VIBE CODERS: Volta is a relatively new tool. It automatically detects the required Node.js version for a project (reads from package.json). Very convenient if you often download other people's projects.

# Install Volta
winget install Volta.Volta

# Install Node.js
volta install node

# Install specific version
volta install node@20

# Pin version for project
volta pin node@20

IMPORTANT for Windows: For Volta to work correctly, you must enable Developer Mode in Windows settings. This allows the utility to create symlinks without requesting administrator rights.

P.S. An extra benefit is that Volta is one of the fastest Node.js version managers.

Check It Works

⚠️ Don't skip this! 10 seconds now saves hours of debugging.

PowerShell or CMD

# Check versions
node --version
npm --version

# Shorter way
node -v
npm -v

# Where npm lives
npm config get prefix

If It Doesn't Work

Most common issue: system can't find Node.js. Quick fix:

Restart terminal — PATH needs a new window
Check PATH manually:

System → Advanced → Environment Variables
Look for:
C:\Program Files\nodejs\
or
%APPDATA%\npm

Reinstall with "Add to PATH" checked

Basic npm Commands

npm is your main tool for Node.js. These are the everyday commands you'll use constantly.

Starting a Project

# Create new package.json (interactively)
npm init

# Create with default settings
npm init -y

# Create with all parameters specified
npm init --yes

Run npm init -y and you get a basic package.json. Think of it like "new document" in Word — your project's starting point.

Installing Dependencies

# Install all dependencies from package.json
npm install
# or shorthand
npm i

# Install specific package
npm install <package-name>
npm i <package-name>

# Install as development dependency (devDependencies)
npm install <package-name> --save-dev
npm i <package-name> -D

# Install globally (available everywhere in system)
npm install -g <package-name>

# Install specific version
npm install lodash@4.17.21
npm i express@4.18.2

IMPORTANT!
Global packages (-g) will bite you in big projects. They create system-specific dependencies. Always install locally in your project.

Managing Packages

# Update all packages
npm update

# Remove package
npm uninstall <package-name>
npm remove <package-name>

# Show globally installed packages
npm list -g --depth=0

# Show project's installed packages
npm list

Running Scripts

# Run script from package.json
npm run <script-name>

# Run standard scripts (start, test, build)
npm start
npm test
npm run build

Useful Flags

# Install without saving to package.json
npm install <package> --no-save

# Install only production dependencies
npm install --production

# Show outdated packages
npm outdated

# Security audit
npm audit
npm audit fix

Cache and Cleaning

# Clear npm cache
npm cache clean --force

# Delete node_modules and reinstall
# Safe deletion in Windows (bypasses path length limit):
npx rimraf node_modules
npm install

Building a Project

FOR VIBE CODERS: Typical scenario: AI wrote a software, there's a package.json, and you don't know what to do. Answer: npm install → npm run build.

Typical package.json Structure

{
  "name": "my-project",
  "version": "1.0.0",
  "main": "dist/index.js",
  "scripts": {
    "build": "tsc",
    "dev": "tsc -w",
    "start": "node dist/index.js",
    "test": "jest",
    "lint": "eslint ."
  },
  "dependencies": {
    "express": "^4.18.0"
  },
  "devDependencies": {
    "@types/node": "^20.0.0",
    "typescript": "^5.3.0"
  }
}

Typical Build Scripts

# Install dependencies
npm install

# Build project
npm run build

# Development mode (watch - automatic rebuild)
npm run dev

# Run in development mode with nodemon
npm run dev:watch

Build Result

After npm run build:

TypeScript compiles to JavaScript
Files appear in the dist/ folder
Ready-to-use code can be deployed

P.S. dist/ is the standard name for the compiled code folder (from "distribution"). It's usually what goes to production.

Alternative Package Managers

npm is not the only option. Yarn and pnpm have their own advantages.

Yarn

# Enable corepack (built into Node.js)
corepack enable
# Activate stable yarn version
corepack prepare yarn@stable --activate

# Initialize project
yarn init

# Install dependencies
yarn
yarn add <package>
yarn add <package> -D

# Build
yarn build

Yarn advantages:

Faster than npm (caches packages)
Prettier console output
Built-in yarn.lock (equivalent to package-lock.json)

In my opinion, there's no major difference between npm and Yarn, you can choose what you like better.

pnpm

# Enable corepack and activate pnpm
corepack enable
corepack prepare pnpm@latest --activate

# Use
pnpm install
pnpm add <package>
pnpm run build

pnpm advantages:

Saves disk space (symlinks)
Faster than npm and yarn
Dependency isolation (better for monorepos)

IMPORTANT!
pnpm uses content-addressable storage. One physical file = many symbolic links. This really saves space — sometimes 3-4x.

Disadvantages: Not all projects work correctly with pnpm due to different node_modules structure.

Building in the Cloud

Need to build but Node.js isn't on the machine? Using someone else's computer? Cloud is the easy answer.

Option 1: GitHub Codespaces

Open repo on GitHub
Click "Code" → "Codespaces"
Spin up a new codespace
In the terminal:

npm install
npm run build

Plus: Free for personal use, nothing to install.

Option 2: StackBlitz

Head to https://stackblitz.com/
Create new project
Upload files (drag & drop)
Terminal:

npm install
npm run build

Option 3: Gitpod

Go to https://gitpod.io/
Paste your repo URL
Dev environment opens automatically

GitHub Actions for Automated Builds

IMO the simplest (and correct) way is CI/CD automation. You push code, GitHub itself builds the project and checks that nothing broke.

Why?

Build runs automatically on push
Can build under different Node.js versions
Artifacts are saved in Release
Automated tests

Workflow Example

Create file .github/workflows/build.yml:

name: Build

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  build:
    runs-on: ubuntu-latest

    strategy:
      matrix:
        node-version: [18.x, 20.x]

    steps:
    - uses: actions/checkout@v4

    - name: Use Node.js ${{ matrix.node-version }}
      uses: actions/setup-node@v4
      with:
        node-version: ${{ matrix.node-version }}
        cache: 'npm'

    - name: Install dependencies
      run: npm ci

    - name: Build
      run: npm run build

    - name: Upload artifacts
      uses: actions/upload-artifact@v4
      with:
        name: dist-${{ matrix.node-version }}
        path: dist/

P.S. Today, GitHub Actions is one of the most popular CI/CD tools. According to surveys, more than 70% of developers use it for build and test automation.

More Complex Example with Release

name: Release

on:
  push:
    tags:
      - 'v*'

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v4

    - name: Setup Node.js
      uses: actions/setup-node@v4
      with:
        node-version: '20'
        cache: 'npm'

    - name: Install and Build
      run: |
        npm ci
        npm run build

    - name: Create Release
      uses: softprops/action-gh-release@v1
      with:
        files: dist/**
      env:
        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

How to Run Build Locally (act)

SENIOR GOTCHA!
act requires Docker Desktop to be installed! Without Docker, the act command will just fail with an error. On Windows, Docker setup is a separate task, be prepared for this.

# Install act
choco install act -y

# Run workflow locally
act

You could say that act is "GitHub Actions locally." Run it — and you have your own personal CI/CD on your computer with blackjack and... oops.

Troubleshooting

90% of Node.js stuff fixes by restarting terminal, clearing cache, or switching versions. Here's the rest.

npm install slow

Most common issue, especially on Windows.

Fixes:

# Use npm ci instead (faster, uses lockfile)
npm ci

# Clear cache
npm cache clean --force

# Switch to faster manager
npm install -g pnpm
pnpm install

Out of memory

# Bump memory (PowerShell)
$env:NODE_OPTIONS = "--max_old_space_size=4096"
npm run build

Permission denied

Windows + perms = pain. Run terminal as admin.

Or move npm folder:

# Global packages in user dir (PowerShell)
mkdir "$env:USERPROFILE\npm-global"
npm config set prefix "$env:USERPROFILE\npm-global"
# Add to PATH

That's it! Covered the main stuff.

Thanks for reading! Subscribe, like, feedback = more good content. Thanks!

My 2026 Agent Workflow: How I Stopped Burning $200/Month on Claude Code, Antigravity & Codex

Fit Happens ML — Mon, 09 Feb 2026 06:44:54 +0000

I've watched devs in 2026 drop $150–200 a month on Claude Code or Antigravity, type "build me an app," and end up with 800 lines of hallucinated garbage plus a shiny "context limit reached" error. I did the same - burned through tokens like they were free beer at a conference happy hour, got nothing usable, and felt like an idiot.

Of course the hype is real: Claude Code (now the most popular coding agent, writing ~90% of Anthropic's own code with Opus 4.5), Antigravity (Google's agent-first IDE that plans autonomously across editor/terminal/browser), Codex (OpenAI's lightweight CLI agent that drafts PRs and runs tests). But "vibe coding" - casually chatting with the agent - fails hard because you're basically asking a very expensive intern to write production code without a spec.

The fix is discipline: a controlled loop instead of chaos. This pipeline is inspired by GitHub's Spec Kit but with more control - multi-model checks, MCP for fresh docs, rules to avoid repetition. Follow these 6 steps, and agents accelerate 3–5x instead of torching your budget.

Step 1: Spec First - Write spec.md Before Any Code

Don't feed the agent any code requests until you have a solid spec.md. Describe the goal, inputs/outputs, constraints, edge cases, and minimum tests. Use your favorite LLM to ask clarifying questions until everything's nailed down. Save it in the repo as spec.md.

Trust me, it'll save your ass - edge cases kill agents otherwise. Without them, Claude Code might choke on CSV quoting hell, Antigravity plans only happy paths, Codex hallucinates invalid inputs.

Example (Word Frequency CLI Analyzer):

# spec.md - Word Frequency CLI Analyzer (MVP)

## Goal
CLI tool that reads a text file (any encoding) and outputs:
- Total word count
- Number of unique words
- Top N most frequent words (default N=10)
- Optional: save results to JSON

Useful for quick text analysis (logs, notes, scraped data, chat exports).

## Inputs/Outputs
- Input: path to text file (required arg)
- Flags/Options:
  - --top N (int, default 10): show top N words
  - --json (flag): output to results.json instead of stdout
  - --min-length M (int, default 3): ignore words shorter than M chars
- Output:
  - stdout: human-readable summary + top list
  - or JSON file if --json

## Constraints
- Python 3.11+
- No external libraries (only stdlib: argparse, collections, json, pathlib, re)
- Handle files up to 100MB (stream reading, no full load into memory)
- Support UTF-8 + common encodings (utf-8, latin-1, cp1252 fallback)
- Case-insensitive counting (normalize to lower)

## Edge Cases
- Empty file → 0 words, empty top list
- File with only punctuation/spaces → 0 words
- Very large file (>50MB) → must stream, no OOM
- Mixed encodings → try utf-8 first, fallback to latin-1 or ignore errors
- Words with hyphens/apostrophes (e.g. "don't", "well-known") → count as one word
- Non-English text (accents, Cyrillic, emojis) → count words properly (split on whitespace + punctuation)
- Invalid path → clear error message + exit 1
- No args → show usage/help

## Tests (minimum set)
- Happy path: small English text file → correct counts & top words
- Empty file → "0 words found"
- File with only punctuation → "0 words found"
- Large-ish file (simulate 10MB lorem ipsum) → no crash, correct stats
- Non-UTF8 file (latin-1) → reads without crash
- JSON output → valid JSON with structure { "total_words": int, "unique_words": int, "top_words": list of [word, count] }

## Non-Goals (out of scope for MVP)
- GUI
- Real-time streaming from stdin
- Stemming/lemmatization
- Stop words filtering
- Multi-file support

Writing the spec sometimes feels like it takes as long as coding the thing yourself. True sometimes. But this is the investment: the skill of forcing AI to write good code is what pays in 2026. Writing everything by hand? That's dinosaur territory now.

Step 2: Plan & Tickets - Break It Down

Feed spec.md to a strong thinking model. Ask it to create a plan: 5–15 small stages, each deliverable in 1–3 senior dev days, each bringing real value (MVP-0 => killer feature => polish).

Then turn the plan into tiny tickets - one focused change per ticket.

Why it works: Big requests overload context and cause drift. Tiny ones keep models sharp and let you catch errors early. Update the plan every 3 stages when reality bites (Pro Tip: use Obsidian for epics and iterative refactoring).

Step 3: Rules & Context - Set Boundaries

Create rules.md (CLAUDE.md, GEMINI.md etc.) with lint rules, forbidden patterns, test commands, style guides. Agents reference it automatically - saves tokens and sanity (no more repeating "use black" 50 times).

Give context: which files to change, repo structure (connect GitHub in Codex/Claude Code), versions/arch bans, known pitfalls, team conventions.

Bonus: Use MCP (Model Context Protocol) - the 2026 standard (thousands of servers now) - to connect fresh library docs. Agents pull actual APIs instead of hallucinating outdated ones. Huge win.

Step 4: Agent Activation - Let Them Loose (Only Now)

Only now connect the repo and activate agents

Step 5: Tests & Multi-Model Check - Every Single Step

For each ticket: define tests in spec/plan, make the agent run them, fix failures.

Don't trust one agent: one codes, another reviews/refactors (Claude for code, Codex for PR suggestions, Antigravity for verification). Cross-check catches blind spots.

Treat agents like interns: clear plan + reviews = better output. Bonus: You'll level up your PM skills massively.

Step 6: Commit & Iterate - Save Points & Refactor

Commit after every successful ticket/test pass. Use branches for experiments - Git is your undo when an agent make sh * t.

Pro Tip: Refactor every 3–4 stages: ask an agent "evaluate current solution for architecture/best practices" while context is fresh.

Conclusion

In 2026, vibe coding isn’t about how fast you can type code anymore.

It’s about how well you can make AI write the code for you.

You’re no longer the senior dev hammering away at the keyboard for eight hours straight. You’re now part product manager, part architect, part tech lead - except your “team” costs $150–200 a month, never takes vacation, but will happily hallucinate garbage if you don’t give them crystal-clear tasks.

Quick Cheatsheet / Memo Spec => plan => rules & context => tiny tickets => agent execution => tests + multi-model cross-check => commit => refactor every few stages.

Thanks for reading!
More no-BS takes on AI agents, tools, and surviving the token apocalypse in my Telegram channel and on X (Twitter).

2x Limits Right Now - Here’s How Much You Can Actually Code Before They Cut It (Codex Promo)

Fit Happens ML — Tue, 03 Feb 2026 11:09:05 +0000

If you blinked yesterday (Feb 2, 2026), you missed it: OpenAI quietly launched a dedicated Codex app for macOS - their shiny new “command center” for AI coding agents. And to make sure everyone notices, they threw in a promo that feels like a holiday gift you didn’t ask for but kinda needed:

Free & Go users get temporary access to Codex (trial mode, limits unknown but “included”).
Paid plans (Plus, Pro, Business, Enterprise, Edu) get 2× rate limits for a “limited time” - no end date announced, so it could vanish tomorrow.

Check your dashboard or the Codex pricing page - if you see doubled numbers or a banner, congrats, you’re in the window.

What Actually Changed (Quick Numbers, No BS)

Limits are counted in messages/tasks over sliding 5-hour windows (local + cloud share the same pool - mix them and it burns faster). Plus code reviews per week.

Rough current promo numbers (from developers.openai.com table + recent announcements):

Plus ($20/mo)

Local messages: ~90–450 / 5h (was 45–225)
Cloud tasks: ~20–120 / 5h (was 10–60)
Code reviews: ~20–50 / week (was 10–25)

Pro ($200/mo)

Local: ~600–3000 / 5h (was 300–1500)
Cloud: ~100–800 / 5h (was 50–400)
Reviews: ~200–500 / week (was 100–250)

Business usually mirrors Plus, Enterprise scales with credits (no hard caps if flexible pricing).

Pro tip: Switch to GPT-5.1-Codex-Mini for local tasks - gets you up to ~4× more messages in the same window (Plus → ~360–1800 local, Pro → ~2400–12000). Cheap way to stretch the promo.

If you hit the wall anyway - buy credits (local ~5 credits/msg, cloud/review ~25). No upgrade needed.

How to Start

1) Open ChatGPT => hit “Try in your IDE” or go to openai.com/codex

2) Choose VS Code (or wait for native app install)

3) Install the “Codex - OpenAI’s coding agent” extension (openai.chatgpt)

4) Sign in with your ChatGPT account

5) Open your repo - Codex sees files, context, can diff, run tests, delegate to cloud

Sandbox mode keeps it safe (limits folder writes/network). If you’re paranoid - start with small local tasks.

P.S. Why This Launch Feels Like They Read Your Mind

Peak OpenAI move: new powerful app + extra allowance right when usage is exploding (they say Codex doubled since GPT-5.2-Codex in December, >1M devs touched it last month).

It’s like they’re saying: “We know you’ll delegate half your workload to agents this week - here’s double the rope.”

By the way - hurry “limited time” usually means “until we see usage spike and panic about costs.” So, grab the extra limits while they’re hot. May your agents ship code, not excuses. 🚀

Thanks for reading.

I’m building open-source stuff and writing about ML/AI in my Telegram channel: https://t.me/FitHappensML and on X/Twitter: https://x.com/FitHappensML

Building a Custom FB2 Converter for LLMs

Fit Happens ML — Thu, 29 Jan 2026 11:39:46 +0000

TL;DR:
I "vibecoded" a custom Python tool to convert legacy .fb2 e-books into structured Markdown (perfect for LLMs/RAG/Obsidian) and Plain Text. No ads, no bloat, just 150 lines of code.

The App: Live Streamlit Demo
The Code:
FitHappensML / fb2-to-md-converter

A lightweight CLI and Web tool to convert FB2 books to Markdown or Plain Text. Includes a built-in Streamlit reader and smart formatting support.
FB2 to TXT/MD Converter & Reader

🚀 Try the Live Demo: fb2-to-md-converter.streamlit.app

✍️ Read the Story behind the code: Vibecoding Your Way Out of Format Hell (Medium)

This project is a Python-based utility for converting .fb2 (FictionBook) files into .txt (plain text) or .md (Markdown). The tool offers two interfaces: a user-friendly web UI built with Streamlit for reading and converting, and a command-line interface (CLI) for fast processing and automation.

✨ Key Features
- Dual Interfaces
  
  🎨 Web UI (Streamlit): Upload your files, read books directly in the browser, and download the result in your desired format.
  
  ⚙️ Command-Line Interface (CLI): Quickly convert files from your terminal, perfect for scripting and batch processing.
- Smart Formatting: An option to convert FB2 tags (like subtitles and emphasis) into corresponding Markdown syntax.
- Dual Export Formats: Save your books as clean .txt or as formatted .md files.
- Built-in Reader…
View on GitHub

Hello, fellow builders!

If you're anything like me, you probably have a digital hoard of books. In my case, it's a massive collection of .fb2 (FictionBook) files. Solid format, xml-based, widely supported... until you need to feed it into a Large Language Model (LLM).

Here's the problem: LLMs eat text, not XML tags.

I needed to convert my entire library into clean, structured Markdown. I needed headers to actually be headers (### Chapter 1), and emphasis to be italics (*wow*), so the model understands the semantic structure of the narrative.

I looked at existing tools.

The Desktop Apps: Bloated, require installation, often Windows-only 90s relics.
The Online Converters: "Upload clean_code.fb2... waiting... Download your file after watching this 30s ad". No thanks.
The Scripts: Most just strip all tags blindly, turning a beautiful dialogue into a wall of text.

If you are a developer in 2026, you don't hunt for software. You vibecode it.

It is faster to tailor a bespoke suit of a script than to shop for ill-fitting off-the-rack solutions. Plus, when you build it, you own the pipeline.

So, I built my own FB2 to Markdown converter. It has a CLI for batch processing and a Streamlit UI because sometimes I just want to read a chapter in the browser.

Here is how I did it, and how you can do it too.

The Strategy: FB2 is just XML

Don't overcomplicate it. An FB2 file is just an XML file with a specific schema. We don't need a heavy e-book library; we need BeautifulSoup.

Here is the core logic. We parse the XML, look for specific tags (<subtitle>, <emphasis>), and map them to Markdown.

The Core Converter

I created a converter.py. The trick is handling nested tags. A paragraph <p> might contain <emphasis> inside it.

from bs4 import BeautifulSoup
from bs4.element import Tag

def _get_formatted_text(tag: Tag) -> str:
    """Recursively process tags to keep italics and bolding."""
    parts = []
    for item in tag.children:
        if isinstance(item, Tag):
            if item.name == 'emphasis':
                parts.append(f'*{item.get_text(strip=True)}*')
            else:
                parts.append(_get_formatted_text(item))
        else:
            parts.append(str(item))
    return "".join(parts)

This recursive function is the secret sauce. Instead of text_content() which flattens everything, this preserves the vibe of the text.

Then, the main loop allows us to choose between "Raw Text" and "Smart Formatting":

def convert_fb2_to_txt(fb2_content: str, smart_formatting: bool = False) -> str:
    soup = BeautifulSoup(fb2_content, 'lxml-xml')
    text_parts = []

    # Extract Metadata (Title, Author)
    description = soup.find('description')
    # ... extraction logic ...

    # Extract Body
    body = soup.find('body')
    for element in body.find_all(['p', 'subtitle', 'empty-line']):
        if element.name == 'p':
            if smart_formatting:
                 text_parts.append(_get_formatted_text(element).strip() + '\n\n')
            else:
                 text_parts.append(element.get_text(strip=True) + '\n\n')
        elif element.name == 'subtitle':
            # Boom: Semantic headers for the LLM
            text_parts.append(f"### {element.get_text(strip=True)}\n\n")

    return "".join(text_parts)

The Interface: Streamlit for Instant Gratification

I love CLI, but sometimes I want to drag-and-drop. Streamlit is perfect for this. It takes 5 minutes to build a UI that looks decent.

In app.py, I process the file and offer two flavors of download:

import streamlit as st
from converter import convert_fb2_to_txt

st.title("📖 FB2 Reader & Converter")

uploaded_file = st.file_uploader("Upload .fb2", type=['fb2'])

if uploaded_file:
    # Read the bytes
    content = uploaded_file.getvalue().decode('utf-8')

    # Dual Conversion
    plain_text = convert_fb2_to_txt(content, smart_formatting=False)
    markdown_text = convert_fb2_to_txt(content, smart_formatting=True)

    # The Reader View
    st.markdown(markdown_text)

    # Sidebar Downloads
    st.sidebar.download_button("Download .md", markdown_text, file_name="book.md")
    st.sidebar.download_button("Download .txt", plain_text, file_name="book.txt")

This gives me immediate visual verification. I can see if the <subtitle> tags are actually rendering as headers before I commit to converting my whole library.

The CLI: For the Serious Batching

Finally, cli.py. Because I'm not going to drag-and-drop 500 books.

import argparse
from converter import convert_fb2_to_txt

# ... setup format args ...

if args.format == 'md':
    result = convert_fb2_to_txt(content, smart_formatting=True)
else:
    result = convert_fb2_to_txt(content, smart_formatting=False)

Now I can just run:
python cli.py "War_and_Peace.fb2" -f md
And get a perfect Markdown file ready for RAG (Retrieval-Augmented Generation) or fine-tuning.

Why "Vibecode" it?

Could I have found a tool to do this? Probably.
Would it handle the specifics of <subtitle> tags nested in <section> blocks exactly how I wanted? No.

By spending an hour writing this, I now have a tool that is:

Fast: No uploads, no ads.
Private: My books stay on my machine.
Correct: The output is formatted exactly for my LLM's consumption.

In the era of AI, the ability to quickly whip up data transformation scripts is a superpower. Don't be afraid to reinvent the wheel if the tire on the existing wheel is flat.

Happy coding!

DEV Community: Fit Happens ML

Anthropic's Free Credit Window Closes April 17. Don't Miss It.

AI Wrote Code But You Don't Have npm? Here's What to Do

Introduction

Methods for Installing Node.js on Windows

Installation via Official Installer

Step 1: Downloading

Why It's Good

Why It Sucks

Installation via Chocolatey

What You Need First

Install Node.js

Why It's Good

Installation via Winget

Commands

Installation via NVM (Recommended for Developers)

Option 1: NVM for Windows

NVM Commands (for Windows)

Option 2: Volta (Modern Alternative)

Check It Works

PowerShell or CMD

If It Doesn't Work

Basic npm Commands

Starting a Project

Installing Dependencies

Managing Packages

Running Scripts

Useful Flags

Cache and Cleaning

Building a Project

Typical package.json Structure

Typical Build Scripts

Build Result

Alternative Package Managers

Yarn

pnpm

Building in the Cloud

Option 1: GitHub Codespaces

Option 2: StackBlitz

Option 3: Gitpod

GitHub Actions for Automated Builds

Why?

Workflow Example

More Complex Example with Release

How to Run Build Locally (act)

Troubleshooting

npm install slow

Out of memory

Permission denied

My 2026 Agent Workflow: How I Stopped Burning $200/Month on Claude Code, Antigravity & Codex

2x Limits Right Now - Here’s How Much You Can Actually Code Before They Cut It (Codex Promo)

What Actually Changed (Quick Numbers, No BS)

How to Start

P.S. Why This Launch Feels Like They Read Your Mind

Building a Custom FB2 Converter for LLMs

FitHappensML / fb2-to-md-converter

A lightweight CLI and Web tool to convert FB2 books to Markdown or Plain Text. Includes a built-in Streamlit reader and smart formatting support.

FB2 to TXT/MD Converter & Reader

✨ Key Features

The Strategy: FB2 is just XML

The Core Converter

The Interface: Streamlit for Instant Gratification

The CLI: For the Serious Batching

Why "Vibecode" it?