# Daniel Doubrovkine

Published articles for Daniel Doubrovkine.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Automatic RSpec Sharding on GitHub Actions

DevFeed: [Automatic RSpec Sharding on GitHub Actions](<https://devfeed.tech/articles/automatic-rspec-sharding-on-github-actions-144065.md>)

Original publisher: [Read original article](<https://code.dblock.org/2026/11/19/automatic-rspec-sharding-on-github-actions.html>)

Author: Daniel Doubrovkine (dblock@dblock.org)

Published: 2026-11-19T00:00:00Z

Content type: tutorial

Language: en

Sources: [Daniel Doubrovkine](<https://devfeed.tech/sources/daniel-doubrovkine.md>)

Topics: [dynamic test splitting](<https://devfeed.tech/topics/dynamic-test-splitting.md>), [RSpec](<https://devfeed.tech/topics/rspec.md>), [GitHub Actions](<https://devfeed.tech/topics/github-actions.md>), [sharding](<https://devfeed.tech/topics/sharding.md>)

Tags: [ci](<https://devfeed.tech/tags/ci.md>), [github-actions](<https://devfeed.tech/tags/github-actions.md>), [rails](<https://devfeed.tech/tags/rails.md>), [rspec](<https://devfeed.tech/tags/rspec.md>), [ruby](<https://devfeed.tech/tags/ruby.md>), [sharding](<https://devfeed.tech/tags/sharding.md>), [testing](<https://devfeed.tech/tags/testing.md>), [timing](<https://devfeed.tech/tags/timing.md>)

### AI overview

The `parallel_tests-ci` reusable GitHub Actions workflow cut Posebook's RSpec time from 395 seconds serially to under 80 seconds on eight workers in every run shown, excluding setup and spec loading. It requires Ruby 3.3 or newer and can run database or other setup commands on each worker. Without timing history, `parallel_tests` groups spec files by size; after successful default-branch pushes, the workflow stores per-file timings in a `runtime.log` artifact. Later runs use the newest available artifact from recent successful runs of the same workflow on the default branch to balance worker loads. Pull requests can use that history but cannot update it.

### Source excerpt

Running RSpec on eight workers got Posebook, a custom Rails CMS, from more than six minutes of RSpec time to about one using parallel_tests-ci that I built to adjust shards automatically as tests get faster or slower, without repeating the GitHub Actions boilerplate for splitting files, running workers, and passing timings between runs. Posebook Benchmarks Each bar shows the slowest worker's RSpec execution time, excluding setup and spec loading. The serial run took 395 seconds. With eight workers, every run shown took less than 80 seconds of RSpec time. Sharding improved further capturing data from previous runs. How to Use It With Ruby 3.3 or newer, add the gem to your Gemfile and run bundle install: gem 'parallel_tests-ci', '0.1.0', require: false In .github/workflows/test.yml, call the reusable workflow at the same version: name: Test on: [push, pull_request] permissions: contents: read actions: read jobs: test: uses: dblock/parallel_tests-ci/.github/workflows/rspec.yml@v0.1.0 with: shards: 8 If your specs need a database or other setup, use the workflow's setup input to run those commands on each worker. How It Works Without timing history, parallel_tests groups spec files by size. After a successful run triggered by a push to the default branch, the workflow saves per-file timings in a runtime.log and uploads it as a GitHub Actions artifact. Before splitting the suite, later runs look for that artifact in recent successful runs of the same workflow on the default branch. They download the newest one still available and use its timings to give each worker roughly the same amount of work. Pull requests can also download the artifact, but cannot update the timing history. Automatic RSpec Sharding on GitHub Actions was originally published by Daniel Doubrovkine at code.dblock.org | tech blog on November 19, 2026.

## The Sunk Cost Fallacy of a Vibe-Coded Custom SaaS

DevFeed: [The Sunk Cost Fallacy of a Vibe-Coded Custom SaaS](<https://devfeed.tech/articles/the-sunk-cost-fallacy-of-a-vibe-coded-custom-saas-134491.md>)

Original publisher: [Read original article](<https://code.dblock.org/2026/11/15/the-sunk-cost-fallacy-of-a-vibe-coded-custom-saas.html>)

Author: Daniel Doubrovkine (dblock@dblock.org)

Published: 2026-11-15T00:00:00Z

Content type: opinion

Language: en

Sources: [Daniel Doubrovkine](<https://devfeed.tech/sources/daniel-doubrovkine.md>)

Topics: [implementation](<https://devfeed.tech/topics/implementation.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [Google Calendar](<https://devfeed.tech/topics/google-calendar.md>), [Claude](<https://devfeed.tech/topics/claude.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>), [feature bloat](<https://devfeed.tech/topics/feature-bloat.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [ai](<https://devfeed.tech/tags/ai.md>), [cli](<https://devfeed.tech/tags/cli.md>), [copilot](<https://devfeed.tech/tags/copilot.md>), [cost](<https://devfeed.tech/tags/cost.md>), [custom](<https://devfeed.tech/tags/custom.md>), [github](<https://devfeed.tech/tags/github.md>), [github-copilot](<https://devfeed.tech/tags/github-copilot.md>), [github-copilot-cli](<https://devfeed.tech/tags/github-copilot-cli.md>), [google](<https://devfeed.tech/tags/google.md>), [google-calendar](<https://devfeed.tech/tags/google-calendar.md>), [mongodb](<https://devfeed.tech/tags/mongodb.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [pull-requests](<https://devfeed.tech/tags/pull-requests.md>), [rails](<https://devfeed.tech/tags/rails.md>), [ruby](<https://devfeed.tech/tags/ruby.md>), [saas](<https://devfeed.tech/tags/saas.md>), [sunk](<https://devfeed.tech/tags/sunk.md>)

### AI overview

Posebook is an open-source event-booking app built to manage a weekly figure-drawing session, handling venues and recurring programs, private invitations, date bookings, attendance, and public schedules. Participants book available dates through an invitation link; the system preserves booking history, keeps contact details private, creates Google Calendar meetings with the organizer and participant, and sends transactional email through a background worker. The author used GitHub Copilot CLI in bounded feature tasks, reviewing designs and pull requests and iterating on requirements. The excerpt notes that cancellations, rescheduling, consent, opt-outs, retries, and acknowledgments must work together, and questions whether this custom system is excessive for a single weekly event; it does not resolve that tradeoff.

### Source excerpt

I organize a weekly figure-drawing session at Enoch's Arts & Coffee in Manhattan. It runs every Monday at 6:30pm and costs $20. It's regularly attended and we were even written up in W42ST. Like any small event, it comes with the usual collection of emails, date juggling, private contact details, and calendar invitations. So, I decided to build a custom SaaS called Posebook to automate all that. The Plan The original idea was that models would register, choose a date, and get a reminder a week before posing. I chose Rails and MongoDB because I already use both, and started with one venue and one recurring program. The application now organizes venues, recurring programs, organizers, invitations, bookings, attendance, and public schedules. It is open source, and the hosted instance serves Enoch's, but could work for your event, too. The organizer creates a venue, adds its location, and sets up one or more recurring programs. A program owns its schedule, booking rules, and managers. The organizer sends a private invitation link to a participant, who creates an account if needed and books an available date. The application checks that the booking is still available, retains its history when it changes, and keeps participant contact information private. When a participant books, a configured Google Calendar integration creates one meeting with the participant and organizer on the guest list and the venue address in the location. Transactional emails go through a background worker. Cancellations, rescheduling, consent, opt-outs, retries, and acknowledgments all need to work together. Building It with an Agent I used GitHub Copilot CLI as an implementation partner. I started by asking for a plan and a name, settled the product and data model, and then gave it bounded feature requests. The agent explored the Rails application, changed code and tests on task branches, and opened pull requests. I reviewed the behavior, corrected the requirements when the implementation got t

## Releases as Code

DevFeed: [Releases as Code](<https://devfeed.tech/articles/releases-as-code-132578.md>)

Original publisher: [Read original article](<https://code.dblock.org/2026/11/12/releases-as-code.html>)

Author: Daniel Doubrovkine (dblock@dblock.org)

Published: 2026-11-12T00:00:00Z

Content type: article

Language: en

Sources: [Daniel Doubrovkine](<https://devfeed.tech/sources/daniel-doubrovkine.md>)

Topics: [releases](<https://devfeed.tech/topics/releases.md>), [Ruby](<https://devfeed.tech/topics/ruby.md>), [npm packages](<https://devfeed.tech/topics/npm-packages.md>), [version-control](<https://devfeed.tech/topics/version-control.md>)

Tags: [automate](<https://devfeed.tech/tags/automate.md>), [code](<https://devfeed.tech/tags/code.md>), [documentation](<https://devfeed.tech/tags/documentation.md>), [github](<https://devfeed.tech/tags/github.md>), [github-actions](<https://devfeed.tech/tags/github-actions.md>), [language](<https://devfeed.tech/tags/language.md>), [libraries](<https://devfeed.tech/tags/libraries.md>), [npm](<https://devfeed.tech/tags/npm.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [readme](<https://devfeed.tech/tags/readme.md>), [release](<https://devfeed.tech/tags/release.md>), [release-workflow](<https://devfeed.tech/tags/release-workflow.md>), [releases](<https://devfeed.tech/tags/releases.md>), [ruby](<https://devfeed.tech/tags/ruby.md>), [rust](<https://devfeed.tech/tags/rust.md>), [stable](<https://devfeed.tech/tags/stable.md>), [tag](<https://devfeed.tech/tags/tag.md>), [test](<https://devfeed.tech/tags/test.md>), [test-it](<https://devfeed.tech/tags/test-it.md>), [testing](<https://devfeed.tech/tags/testing.md>), [updating](<https://devfeed.tech/tags/updating.md>)

### AI overview

The article argues that release workflows should be treated as testable project code because a partial failure can leave published packages, tags, or development versions inconsistent. It describes npm-package-release, ruby-gem-release, and rust-crate-release, showing lifecycle hooks that update a README's "Release Status" section to identify the stable version at the release tag and the next version on the development branch. Each example tests the actual workflow with project fixtures and checks both versions. The author reports that adopting shared libraries reduced release-related JavaScript and Ruby code by 66% across four cited projects; the excerpt also names projects using the three libraries.

### Source excerpt

A release needs to be reliable, which means it needs to be testable. A typical release selects a version, updates a changelog, builds an artifact, creates a commit and a tag, publishes the package, creates a GitHub Release, and often prepares the next development version. Projects add their own steps, such as updating version references in documentation, and these steps need to agree on what was released. If one breaks, the release fails halfway through, leaving a published package without a matching tag or a development version that wasn't updated. You can't always undo a published package and start over. Test your release code. Releases Are Software I've spent plenty of time maintaining release instructions, shell scripts, and GitHub Actions YAML. They automate the work, but the interesting logic tends to be spread across commands that are hard to exercise without actually making a release. I wanted to treat a release workflow like the rest of the project: write it in code, customize it in code, and test the behavior that matters. This idea has become a family of libraries: npm-package-release, ruby-gem-release, and rust-crate-release. Each brings the workflow into the language of the project it releases. For example, a project's README on the default branch may describe features that haven't been released yet. Grape's README identifies the upcoming version and links to the stable release so users don't confuse the two. After a release, I want the development README to say "You're reading the documentation for the next release, v1.2.3." The README at the release tag should identify the stable version instead. I could do this with a shell script that searches and replaces text, then hope it still works the next time I release. Instead, I can write the release logic in the project's language and test it. Updating the README These examples assume a ## Release Status section in README.md. Each replaces that section during release preparation and again when preparing t

## How I Learned to Use Copilot Sessions 400 Million Tokens Later

DevFeed: [How I Learned to Use Copilot Sessions 400 Million Tokens Later](<https://devfeed.tech/articles/how-i-learned-to-use-copilot-sessions-400-million-tokens-later-126487.md>)

Original publisher: [Read original article](<https://code.dblock.org/2026/11/10/how-i-learned-to-use-copilot-sessions-400-million-tokens-later.html>)

Author: Daniel Doubrovkine (dblock@dblock.org)

Published: 2026-11-10T00:00:00Z

Content type: tutorial

Language: en

Sources: [Daniel Doubrovkine](<https://devfeed.tech/sources/daniel-doubrovkine.md>)

Topics: [GitHub Copilot CLI](<https://devfeed.tech/topics/github-copilot-cli.md>), [AI Context Management](<https://devfeed.tech/topics/ai-context-management.md>), [experience report](<https://devfeed.tech/topics/experience-report.md>), [Tool](<https://devfeed.tech/topics/tool.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [context](<https://devfeed.tech/tags/context.md>), [context-switch](<https://devfeed.tech/tags/context-switch.md>), [copilot](<https://devfeed.tech/tags/copilot.md>), [development](<https://devfeed.tech/tags/development.md>), [github-copilot-cli](<https://devfeed.tech/tags/github-copilot-cli.md>), [linter](<https://devfeed.tech/tags/linter.md>), [local](<https://devfeed.tech/tags/local.md>), [logs](<https://devfeed.tech/tags/logs.md>), [markdown](<https://devfeed.tech/tags/markdown.md>), [model](<https://devfeed.tech/tags/model.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [restore](<https://devfeed.tech/tags/restore.md>), [sessions](<https://devfeed.tech/tags/sessions.md>), [source-code](<https://devfeed.tech/tags/source-code.md>), [switch](<https://devfeed.tech/tags/switch.md>), [tokens](<https://devfeed.tech/tags/tokens.md>), [trees](<https://devfeed.tech/tags/trees.md>), [unrelated](<https://devfeed.tech/tags/unrelated.md>), [using](<https://devfeed.tech/tags/using.md>), [waiting](<https://devfeed.tech/tags/waiting.md>)

### AI overview

Using one Copilot CLI conversation across unrelated work led to about 4,322 model calls in three and a half days, with 11.4 million non-cached input, 2.4 million output, and 411 million cached input tokens. Cached context may be counted repeatedly, so that figure does not represent tokens written or generated and does not directly indicate cost. To reduce unrelated context and the time spent restoring and saving it, the author organizes project checkouts and task worktrees under `~/source`, starts Copilot there, then uses `/resume` to open the session picker, `n` to create sessions, `/rename` to name them after repositories, and `/cwd` to set each session's working directory. Naming a session does not change its directory.

### Source excerpt

I recently built a Markdown linter with GitHub Copilot CLI. In between, I reviewed other projects, edited this blog, and generally treated one conversation as a terminal into which I could dump whatever I was doing next. I really loved the fact that Copilot would context switch, do some work, then go back to what it was doing. It's so smart! Well, that may have burnt some extra tokens. Counting Tokens The local usage logs for the roughly three-and-a-half-day development window showed approximately 4,322 model calls, including delegated agents: Token Type Millions Non-cached input 11.4 Output 2.4 Cached input 411 That's roughly 14 million non-cached input and output tokens, plus more than 400 million cached input tokens. Cached input is previously processed context reused across requests. The same context can be counted repeatedly, so 411 million doesn't mean I wrote 411 million tokens or that Copilot generated that much code. It also doesn't translate directly into dollar spend: cached input has different accounting from non-cached input and output. Still, I had given it a lot of unrelated history to carry around and wasted a lot of time waiting for it to restore and save context. Start a Session, Give It a Name Since then, I've been using Copilot CLI's named sessions more. Here's the workflow that is working for me. My source code lives in ~/source. I group related projects together, keeping my forks and upstream checkouts in the same folder. Git working trees fit into the same layout, named after the project and task. For example, here's how I'd add task-specific working trees alongside my fork of ESLint's Markdown plugin and its upstream checkout: ~/source/ `-- eslint/ `-- markdown/ |-- upstream-markdown/ # upstream checkout |-- dblock-markdown/ # my fork |-- dblock-markdown-parser-fix/ # working tree `-- dblock-markdown-docs/ # working tree I start a single copilot process in ~/source and switch between sessions inside it. cd ~/source copilot --yolo --resume Ins

## Releasing Ruby Gems with OIDC and GitHub Actions

DevFeed: [Releasing Ruby Gems with OIDC and GitHub Actions](<https://devfeed.tech/articles/releasing-ruby-gems-with-oidc-and-github-actions-122503.md>)

Original publisher: [Read original article](<https://code.dblock.org/2026/11/07/releasing-ruby-gems-with-oidc-and-github-actions.html>)

Author: Daniel Doubrovkine (dblock@dblock.org)

Published: 2026-11-07T00:00:00Z

Content type: tutorial

Language: en

Sources: [Daniel Doubrovkine](<https://devfeed.tech/sources/daniel-doubrovkine.md>)

Topics: [project release](<https://devfeed.tech/topics/project-release.md>), [GitHub Actions](<https://devfeed.tech/topics/github-actions.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [rubygems](<https://devfeed.tech/topics/rubygems.md>), [Ruby](<https://devfeed.tech/topics/ruby.md>), [OpenID connect (OIDC)](<https://devfeed.tech/topics/oidc.md>)

Tags: [github-actions](<https://devfeed.tech/tags/github-actions.md>), [oidc](<https://devfeed.tech/tags/oidc.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [ruby](<https://devfeed.tech/tags/ruby.md>)

### AI overview

ruby-gem-release automates Ruby gem release bookkeeping through Ruby tasks and a reusable GitHub Actions workflow. RubyGems Trusted Publishing provides short-lived credentials, avoiding a stored RubyGems API key; after setup, collaborators with write access can dispatch releases. The example reads the version from a Ruby constant, dates the changelog before publishing, then increments the version and adds a "Next" section. It supports Intridea and Keep a Changelog formats. First publication requires configuring a trusted publisher and passing the numeric RubyGems account ID; later releases omit that input. For customization, Ruby callbacks expose steps such as changelog preparation, building and publishing the gem, Git tagging, and GitHub release creation as ordinary methods that can be tested.

### Source excerpt

The traditional approach for automating Ruby gem releases is to use release-gem. It's super simple. You can also build upon it when you need something beyond the plain rake release, such as updating a CHANGELOG.md, by rolling miles of brittle GitHub Actions YAML and shell script AI slop. Instead, I've been asking AI to follow a hand-crafted RELEASING.md. It can run tests, date CHANGELOG.md, ask me for a RubyGems OTP, make the release, increment the version of the next developer iteration. This works well. Still, AI is a very blunt tool for something that should be mechanized. Therefore, I built ruby-gem-release to automate all release bookkeeping in Ruby in an extensible workflow. The release runs in GitHub Actions. RubyGems Trusted Publishing supplies short-lived credentials, so there is no RubyGems API key to store in GitHub secrets or share with other maintainers. After setup, collaborators with write access can dispatch releases too. As an example, I added it to ruby-link-checker. Here's the Rakefile addition: require 'ruby-gem-release/workflow/ruby_gem' require 'ruby-gem-release/changelog' RubyGemRelease::Workflow::RubyGem.new( version: RubyGemRelease::Version::RubyConstant.new(path: 'lib/ruby-link-checker/version.rb', constant: 'VERSION'), changelog: RubyGemRelease::Changelog::Intridea.new(placeholder: '* Your contribution here.') ).install_tasks The version strategy reads a constant from lib/ruby-link-checker/version.rb: module LinkChecker VERSION = '0.5.0'.freeze end The CHANGELOG.md in this project is in the Intridea style. The gem also supports Keep a Changelog. Before publishing 0.5.0 the CHANGELOG.md is updated with a date. After publishing, the VERSION constant is incremented to 0.5.1, and CHANGELOG.md is updated with a Next section. Add .github/workflows/release.yml to call the reusable release workflow. The optional rubygems-owner input accepts your numeric RubyGems account ID when publishing a new gem for the first time: name: Release on: workflow_di

## Linting Both Prose and Embedded Code with RuboCop

DevFeed: [Linting Both Prose and Embedded Code with RuboCop](<https://devfeed.tech/articles/linting-both-prose-and-embedded-code-with-rubocop-122102.md>)

Original publisher: [Read original article](<https://code.dblock.org/2026/11/06/linting-both-prose-and-embedded-code-with-rubocop.html>)

Author: Daniel Doubrovkine (dblock@dblock.org)

Published: 2026-11-06T00:00:00Z

Content type: article

Language: en

Sources: [Daniel Doubrovkine](<https://devfeed.tech/sources/daniel-doubrovkine.md>)

Topics: [Markdown](<https://devfeed.tech/topics/markdown.md>), [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>), [generative-ai-tools](<https://devfeed.tech/topics/generative-ai-tools.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>), [Parsing](<https://devfeed.tech/topics/parsing.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [code](<https://devfeed.tech/tags/code.md>), [development](<https://devfeed.tech/tags/development.md>), [documentation](<https://devfeed.tech/tags/documentation.md>), [jekyll](<https://devfeed.tech/tags/jekyll.md>), [linter](<https://devfeed.tech/tags/linter.md>), [linting](<https://devfeed.tech/tags/linting.md>), [markdown](<https://devfeed.tech/tags/markdown.md>), [node-js](<https://devfeed.tech/tags/node-js.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [options](<https://devfeed.tech/tags/options.md>), [port](<https://devfeed.tech/tags/port.md>), [release](<https://devfeed.tech/tags/release.md>), [ruby](<https://devfeed.tech/tags/ruby.md>), [style](<https://devfeed.tech/tags/style.md>), [testing](<https://devfeed.tech/tags/testing.md>), [usability](<https://devfeed.tech/tags/usability.md>), [workflow](<https://devfeed.tech/tags/workflow.md>)

### AI overview

The author introduces rubocop-prose to lint Markdown and plain text alongside embedded Ruby using RuboCop. Install and enable rubocop-md, rubocop-prose, and rubocop-spellcheck; then run `bundle exec rubocop`. rubocop-prose checks document structure, whitespace, and YAML front matter, with configurable editorial rules. rubocop-spellcheck checks prose, comments, and strings using an American English dictionary and supports project vocabulary; Ruby identifier checks are optional. rubocop-md checks Ruby in explicitly tagged Markdown code blocks when autodetection is disabled, leaving other languages alone. Safe autocorrection can join wrapped paragraphs while preserving intentional hard breaks. The generated spelling dictionary should be reviewed before committing because it will accept remaining typos. The excerpt notes that proposed Markdown rules were rejected from rubocop-md as out of scope: that plugin lints Ruby within Markdown, not Markdown itself.

### Source excerpt

My father is a poetry translator, so perhaps my obsession with prose runs in the family. This started before Markdown: I wrote rubocop-exception_messages after noticing inconsistent exception messages in Grape. After I replaced this blog's Python spell checker with a RuboCop plugin I still had a Node installation to check Markdown. Since it's a Jekyll blog, and the build is Ruby, the spelling checker is Ruby, and my default set of code examples are also Ruby, why was formatting the README Node.js? I first tried extending rubocop-md, proposing prose checks and parser diagnostics, a reusable Markdown parser, hidden cop-directive fixes, front-matter handling, and preserving prose alongside Ruby corrections. The parser and interoperability work were merged in #57, but the proposed markdownlint rules were rejected out of scope because rubocop-md lints Ruby within Markdown, not Markdown itself. Introducing rubocop-prose, a RuboCop plugin for Markdown and plain text. I also replaced this blog's Markdown linter with it. It's an AI-assisted port from JavaScript markdownlint and Ruby markdownlint, my custom single-line-paragraphs rule, rubocop-md, and rubocop-spellcheck, plus ideas from upstream issues, pull requests, and forks. I burnt 11.4 million input and 2.4 million output non-cached tokens for development, publishing the initial release in 16 hours, and iterating to 0.2.0 over the next 2 days. My workflow was to start from scratch, then have AI write the PRs, and always steer: reviewing behavior, questioning defaults, and simplifying the user-facing settings by reading PR descriptions and generated documentation. I barely read code as I mostly cared about usability of the linter. For example, I asked to merge EnforcedStyle and Style. That meant consolidating overlapping options, considering a breaking change, and aligning names across cops. Adding Prose to RuboCop Add to your Gemfile: gem 'rubocop-md', '~> 3.0', require: false gem 'rubocop-prose', '~> 0.2.0', require: f

## How to Distribute a Rust App with Cargo, Homebrew, MSI, and WinGet

DevFeed: [How to Distribute a Rust App with Cargo, Homebrew, MSI, and WinGet](<https://devfeed.tech/articles/how-to-distribute-a-rust-app-with-cargo-homebrew-msi-and-winget-118967.md>)

Original publisher: [Read original article](<https://code.dblock.org/2026/11/04/distributing-a-rust-app-everywhere.html>)

Author: Daniel Doubrovkine (dblock@dblock.org)

Published: 2026-11-04T00:00:00Z

Content type: tutorial

Language: en

Sources: [Daniel Doubrovkine](<https://devfeed.tech/sources/daniel-doubrovkine.md>)

Topics: [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Homebrew](<https://devfeed.tech/topics/homebrew.md>), [GitHub](<https://devfeed.tech/topics/github.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [Linux](<https://devfeed.tech/topics/linux.md>)

Tags: [ai-coding-agents](<https://devfeed.tech/tags/ai-coding-agents.md>), [application](<https://devfeed.tech/tags/application.md>), [archive](<https://devfeed.tech/tags/archive.md>), [arithmetic](<https://devfeed.tech/tags/arithmetic.md>), [calculator](<https://devfeed.tech/tags/calculator.md>), [changelog](<https://devfeed.tech/tags/changelog.md>), [ci](<https://devfeed.tech/tags/ci.md>), [cli](<https://devfeed.tech/tags/cli.md>), [clippy](<https://devfeed.tech/tags/clippy.md>), [command-line](<https://devfeed.tech/tags/command-line.md>), [cross-platform](<https://devfeed.tech/tags/cross-platform.md>), [delphi](<https://devfeed.tech/tags/delphi.md>), [distribution](<https://devfeed.tech/tags/distribution.md>), [dry-run](<https://devfeed.tech/tags/dry-run.md>), [fmt](<https://devfeed.tech/tags/fmt.md>), [git](<https://devfeed.tech/tags/git.md>), [homebrew](<https://devfeed.tech/tags/homebrew.md>), [msi](<https://devfeed.tech/tags/msi.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [rust](<https://devfeed.tech/tags/rust.md>), [winget](<https://devfeed.tech/tags/winget.md>)

### AI overview

A Git tag is the source of truth for excalc releases: CI publishes the crate, builds portable archives and a Windows MSI from that tag, then attaches them to the GitHub release. The guide covers Cargo metadata and validation, crates.io Trusted Publishing with short-lived OIDC credentials, and a plain build matrix as a lighter alternative to cargo-dist. macOS archives remain unsigned and unnotarized, so downloaded binaries are blocked by Gatekeeper; the article gives a temporary quarantine-removal step and recommends signing and notarization for production. The MSI uses cargo-wix with a stable UpgradeCode. Homebrew builds the tagged source and needs its formula URL and checksum updated and validated after artifacts succeed; Homebrew 6 also requires tap or formula trust. WinGet uses the released x64 MSI and an asynchronously reviewed Microsoft manifest PR. Later updates can be submitted automatically with WinGet Releaser, which requires a cross-repository token and an already accepted package version. A release checklist coordinates version changes, CI, tagging, artifact verification, and follow-up on the WinGet PR.

### Source excerpt

I recently ported my 1996 Pascal/Delphi calculator to Rust. The result is excalc, a cross-platform command-line application and MCP server. Rust makes it easy to compile an application on every platform. Distributing it via crates.io, MSI, Homebrew or WinGet needed more work. Paste this cookbook into your favorite AI prompt to get it done. We trigger a distribution from GitHub Releases: a Git tag identifies the new version, CI publishes the crate from that tag, builds portable archives and an MSI from that tag, and attaches everything to the release. Homebrew downloads the tagged source archive. WinGet points at the released MSI. Prepare the Rust Package Start with complete package metadata in Cargo.toml. [package] name = "excalc" version = "0.3.0" edition = "2021" authors = ["Daniel Doubrovkine and contributors"] description = "An expression calculator CLI tool and MCP server built for AI coding agents to outsource arithmetic." license = "MIT" repository = "https://github.com/dblock/excalc-rs" default-run = "excalc" Add every binary you want Cargo and the installer to build. [[bin]] name = "excalc" path = "src/main.rs" [[bin]] name = "calc" path = "src/main.rs" [[bin]] name = "excalc-mcp" path = "src/bin/excalc-mcp.rs" required-features = ["mcp"] Note the double brackets in [[bin]]. TOML calls this an array of tables, where each [[bin]] block adds another executable with its own name and source path. In excalc, mcp is a default feature. CLI-only users can opt out with cargo install excalc --no-default-features; release builds retain the default features. Add a LICENSE, README.md, and CHANGELOG.md, then verify what will be uploaded. cargo fmt --all -- --check cargo clippy --all-targets --all-features -- -D warnings cargo test --all-features cargo publish --dry-run The dry run packages the crate and compiles the packaged copy. Publish to crates.io For excalc, I published the first version manually, then configured a trusted CI publisher for subsequent releases. Creat

## Introducing Svet: A Git Repository Linter

DevFeed: [Introducing Svet: A Git Repository Linter](<https://devfeed.tech/articles/introducing-svet-a-git-repository-linter-110590.md>)

Original publisher: [Read original article](<https://code.dblock.org/2026/10/31/introducing-svet-a-git-repository-linter.html>)

Author: Daniel Doubrovkine (dblock@dblock.org)

Published: 2026-10-31T00:00:00Z

Content type: release

Language: en

Sources: [Daniel Doubrovkine](<https://devfeed.tech/sources/daniel-doubrovkine.md>)

Topics: [lint](<https://devfeed.tech/topics/lint.md>), [Git](<https://devfeed.tech/topics/git.md>), [ESLint](<https://devfeed.tech/topics/eslint.md>), [Repository](<https://devfeed.tech/topics/repository.md>), [Tool](<https://devfeed.tech/topics/tool.md>), [Prettier](<https://devfeed.tech/topics/prettier.md>)

Tags: [eslint](<https://devfeed.tech/tags/eslint.md>), [git](<https://devfeed.tech/tags/git.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [lint](<https://devfeed.tech/tags/lint.md>), [linter](<https://devfeed.tech/tags/linter.md>), [nodejs](<https://devfeed.tech/tags/nodejs.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [plugin](<https://devfeed.tech/tags/plugin.md>), [portable](<https://devfeed.tech/tags/portable.md>), [pre-commit](<https://devfeed.tech/tags/pre-commit.md>), [repository](<https://devfeed.tech/tags/repository.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

Svet is a JavaScript repository linter that separates file selection from checks, so checks can use both file contents and Git path metadata without requiring a language parser. Its default Git selector checks tracked text files for LF endings and includes binary paths in the inventory used for filename checks. The `--precommit` mode checks staged Git-index snapshots without staging, stashing, or fixing files; revision comparisons use target-commit contents and do not fetch branches. Separate plugins provide checks such as trailing whitespace and path case. The excerpt contrasts this with an ESLint portability plugin that detects case and Unicode-normalization collisions, Windows-invalid names, and configurable path-length limits, but sees the current filesystem rather than staged snapshots and cannot fix filesystem names.

### Source excerpt

The idea for Svet came from a private repository at work, where checking filename case helps catch portability problems like Logo.svg and logo.svg colliding on a case-insensitive Windows filesystem. These checks are implemented in pure JavaScript. That seemed like a useful job for a reusable repository linter. I went looking for an existing tool. Tool Why it isn't enough here ESLint Can check filenames with a processor; byte-level checks and Git snapshots need custom plumbing. Oxlint Arbitrary non-JS/TS files don't reach its lint rules. Biome Checks supported languages, not arbitrary repository files. Stylelint Built for stylesheet rules; repository-wide checks need custom code. markdownlint-cli2 Can check filenames, but Markdown parsing isn't a byte-level checking API. HTML-validate Requires HTML or template transformations, not a general file-checking API. Prettier Skips or rejects unsupported formats; doesn't check repository-wide path rules. lint-staged Can run the checks, but doesn't supply rules or Git-index snapshots itself. Prettier is a formatter, and lint-staged is a task runner. They're in this list because they also appear in development and CI workflows. The important distinction is selecting a path, checking its name, understanding its contents, and choosing which version of those contents to inspect. Those are four different things. I built Svet for that job. Then I doubted myself and took a detour extending ESLint with eslint-plugin-portable-paths. It checks four portability problems: case-insensitive file and directory collisions, Unicode-normalization collisions, Windows-invalid names such as NUL.txt, and paths or individual names exceeding configurable lengths. It's almost everything. The remaining limitations of the eslint approach are about which files and bytes we're checking. This plugin sees the current filesystem, including untracked paths, and is not Git-aware, so a pre-commit hook would check the working tree, not the staged snapshot. ESLi

## The Matter of Taste

DevFeed: [The Matter of Taste](<https://devfeed.tech/articles/the-matter-of-taste-109754.md>)

Original publisher: [Read original article](<https://code.dblock.org/2026/10/30/the-matter-of-taste.html>)

Author: Daniel Doubrovkine (dblock@dblock.org)

Published: 2026-10-30T00:00:00Z

Content type: opinion

Language: en

Sources: [Daniel Doubrovkine](<https://devfeed.tech/sources/daniel-doubrovkine.md>)

Topics: [dry-run](<https://devfeed.tech/topics/dry-run.md>), [User interface design](<https://devfeed.tech/topics/ui-design.md>), [Tool](<https://devfeed.tech/topics/tool.md>), [human review](<https://devfeed.tech/topics/human-review.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-slop](<https://devfeed.tech/tags/ai-slop.md>), [api](<https://devfeed.tech/tags/api.md>), [choice](<https://devfeed.tech/tags/choice.md>), [design](<https://devfeed.tech/tags/design.md>), [developer-tools](<https://devfeed.tech/tags/developer-tools.md>), [dry-run](<https://devfeed.tech/tags/dry-run.md>), [making](<https://devfeed.tech/tags/making.md>), [open-source](<https://devfeed.tech/tags/open-source.md>)

### AI overview

For Svet, a Git and filesystem linter, the author weighs two meanings for `--dry-run`. A write-prevention definition runs checks and reports findings without changing files; with `--fix`, it prepares fixes but does not apply them. Since ordinary checks already make no writes, this makes the flag redundant unless fixing is requested. The author instead favors previewing the selected operation: `--dry-run` lists involved files and checks without running them, while `--fix --dry-run` runs checks and prepares fixes but stops before writing. GitHub Copilot CLI suggested `--plan` for the checking preview, but the author prefers a smaller flag vocabulary over more explicit combinations such as `--plan`, `--fix`, and `--fix-dry-run`. AI can explain and implement either design; choosing between coherent options may depend on personal taste. The provided text ends mid-sentence, so this overview reflects the excerpt.

### Source excerpt

While working on Svet, a Git and filesystem linter, I had a conversation with GitHub Copilot CLI about a flag. The tool checks files. We were adding automatic fixes. Naturally, I wanted to preview changes before allowing the tool to write them. The first suggestion was --fix-dry-run. I preferred a global --dry-run that could apply to both checking and fixing. Simple enough. Except checking already doesn't write anything. What should a dry run of a check do? One answer is that a dry run prohibits writes. Run all the checks, report the findings, and leave the files alone. With --fix, calculate the fixes but don't apply them. Without --fix, the flag changes nothing. That's a consistent definition. It also makes the flag redundant for the default operation. I wanted another definition: preview the operation I asked for. # Check files. svet # Check files, fix what can be fixed, and check again. svet --fix # Show which files and checks would be involved, without running checks. svet --dry-run # Run checks and prepare fixes, without changing files. svet --fix --dry-run In the checking case, the preview stops before running checks. In the fixing case, it has to run checks to discover what needs fixing, then stops before writing. You could object that --dry-run now does different things. You could also say it does the same thing: shows what the selected operation would do. Copilot suggested calling the checking preview --plan. I don't like to --plan. I find the --plan, --fix, and --fix-dry-run interface horrible, even though each flag names something specific. I don't like to repeat myself and I am a human capable of calculating the 2x2 matrix of options in my head. I opt for a smaller vocabulary using my decades of experience making and using developer tools. AI can explain both designs and implement either one. It can point out that checking is already read-only, suggest another flag, and produce the tests. I still have to decide which interface I want to use and every suc

## One Tool for the (Spell Checking) Job

DevFeed: [One Tool for the (Spell Checking) Job](<https://devfeed.tech/articles/one-tool-for-the-spell-checking-job-107249.md>)

Original publisher: [Read original article](<https://code.dblock.org/2026/10/29/one-tool-for-the-spell-checking-job.html>)

Author: Daniel Doubrovkine (dblock@dblock.org)

Published: 2026-10-29T00:00:00Z

Content type: article

Language: en

Sources: [Daniel Doubrovkine](<https://devfeed.tech/sources/daniel-doubrovkine.md>)

Topics: [Tool](<https://devfeed.tech/topics/tool.md>), [Markdown](<https://devfeed.tech/topics/markdown.md>), [Node.js](<https://devfeed.tech/topics/node-js.md>), [npm](<https://devfeed.tech/topics/npm.md>), [pip](<https://devfeed.tech/topics/pip.md>), [bazel](<https://devfeed.tech/topics/bazel.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [blog](<https://devfeed.tech/tags/blog.md>), [ci](<https://devfeed.tech/tags/ci.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [environment](<https://devfeed.tech/tags/environment.md>), [html](<https://devfeed.tech/tags/html.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [jekyll](<https://devfeed.tech/tags/jekyll.md>), [linter](<https://devfeed.tech/tags/linter.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [plugin](<https://devfeed.tech/tags/plugin.md>), [plugins](<https://devfeed.tech/tags/plugins.md>), [project](<https://devfeed.tech/tags/project.md>), [python](<https://devfeed.tech/tags/python.md>), [ruby](<https://devfeed.tech/tags/ruby.md>), [runtime](<https://devfeed.tech/tags/runtime.md>), [rust](<https://devfeed.tech/tags/rust.md>), [testing](<https://devfeed.tech/tags/testing.md>), [tokens](<https://devfeed.tech/tags/tokens.md>), [tools](<https://devfeed.tech/tags/tools.md>)

### AI overview

The author argues for adding spelling checks as plugins to tools a project already uses, avoiding a separate runtime, configuration, and CI job. They replaced a Python checker that took over three minutes on a Ruby Jekyll blog with a RuboCop plugin, integrating spelling into the existing command and configuration. The listed plugins cover Ruby through RuboCop, Rust through Dylint, Markdown through markdownlint, and Markdown, HTML, plain text, and JavaScript/TypeScript prose through Prettier. The Prettier plugin uses existing syntax trees to separate prose from program structure; an example flags "helo" and suggests alternatives. The author cautions that Copilot initially built that plugin as a wrapper around the markdownlint spellcheck rule.

### Source excerpt

I've built four spell-checking plugins in the last week. This is not an unhealthy interest in spelling. The cost of rolling tools out is the cost of tokens + my time supervising AI. So, before adding another language runtime, package manager, configuration file, and CI job to your project, consider spending an hour vibe coding the missing plugin. This blog used to run a Python spell checker that took more than three minutes. It's a Jekyll blog, which is Ruby. Why was I maintaining a Python environment to tell me that I misspelled "hello"? I replaced it with a RuboCop plugin. Spelling became another cop, with the same configuration, exclusions, command, and CI integration as the rest of the checks. A Rust project shouldn't need my Ruby setup to check its comments. A JavaScript project that already runs Prettier shouldn't need an additional Markdown linter just to check spelling. You can either keep assembling a Frankenstein collection of tools, roll out a custom script, or you can ask AI to build the missing feature. AI loves simplicity and consistent patterns. This approach pays forward. Here's my recent zoo. rubocop-spellcheck adds spelling to RuboCop for Ruby comments, strings, identifiers, Markdown, RDoc, AsciiDoc, and plain text. dylint-spellcheck adds spelling to Dylint for Rust comments, Rustdoc attributes, Markdown, and plain text. markdownlint-rule-spellcheck adds spelling to the Markdown linter you might already be running. prettier-plugin-spellcheck adds spelling to Prettier for Markdown, HTML, plain text, and JavaScript/TypeScript prose. markdownlint-rule-single-line-paragraphs keeps Markdown paragraphs on one source line. Everything builds on top of simple and powerful platforms. The Prettier version is a good example. Prettier already parses Markdown, HTML, JavaScript, and TypeScript. I used its syntax trees to distinguish prose from program structure instead of inventing another parser. Comments and visible text are reasonable things to spellcheck, too

## I Am Just One Engineer Armed with AI

DevFeed: [I Am Just One Engineer Armed with AI](<https://devfeed.tech/articles/i-am-just-one-engineer-armed-with-ai-98269.md>)

Original publisher: [Read original article](<https://code.dblock.org/2026/10/23/i-am-just-one-engineer-armed-with-ai.html>)

Author: Daniel Doubrovkine (dblock@dblock.org)

Published: 2026-10-23T00:00:00Z

Content type: opinion

Language: en

Sources: [Daniel Doubrovkine](<https://devfeed.tech/sources/daniel-doubrovkine.md>)

Topics: [GitHub](<https://devfeed.tech/topics/github.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Continuous integration](<https://devfeed.tech/topics/continuous-integration.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [JavaScript](<https://devfeed.tech/topics/javascript.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [bot](<https://devfeed.tech/tags/bot.md>), [bug](<https://devfeed.tech/tags/bug.md>), [ci](<https://devfeed.tech/tags/ci.md>), [compatibility](<https://devfeed.tech/tags/compatibility.md>), [coverage](<https://devfeed.tech/tags/coverage.md>), [danger](<https://devfeed.tech/tags/danger.md>), [documentation](<https://devfeed.tech/tags/documentation.md>), [email](<https://devfeed.tech/tags/email.md>), [engineer](<https://devfeed.tech/tags/engineer.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [features](<https://devfeed.tech/tags/features.md>), [github](<https://devfeed.tech/tags/github.md>), [github-issue](<https://devfeed.tech/tags/github-issue.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [maintenance](<https://devfeed.tech/tags/maintenance.md>), [mongoid](<https://devfeed.tech/tags/mongoid.md>), [new-features](<https://devfeed.tech/tags/new-features.md>), [numbers](<https://devfeed.tech/tags/numbers.md>), [october](<https://devfeed.tech/tags/october.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [performance](<https://devfeed.tech/tags/performance.md>), [ruby](<https://devfeed.tech/tags/ruby.md>), [rust](<https://devfeed.tech/tags/rust.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

Across ten days, the author reports 295 pull requests in 49 repositories, 257 merged, and 30 releases, spanning library features, maintenance, spelling tools, and app upgrades. Three spelling tools for Ruby, Rust, and JavaScript integrate with each language's lint workflow; the first two use Kotoshu and the JavaScript rule uses CSpell. Checking 618 Markdown files reportedly fell from over three minutes to 3.69 seconds. Other work included Hashie features and releases, provider-aware email parsing, GitHub issue automation, and Mongoid fixes found through legacy and modern compatibility testing. Eleven chat bots were upgraded after CVEs. The author says AI handled much of the typing, while they selected work, checked reproductions, reviewed changes, managed compatibility and release decisions, and drew on decades of programming experience to steer it. Usage records, after removing duplicates, totaled about 1.196 billion input-plus-output tokens, 97.4% of input tokens cache reads. These figures and examples come from the supplied excerpt.

### Source excerpt

I made 295 pull requests across 49 GitHub repos and did 30 project releases burning ~1.2 billion AI tokens in ten days. I am just one Engineer armed with AI. That is a lot of typing I did not do. I certainly did not read or write any code. This is a follow-up to AI Wants to Eat Your Project Backlog, where I described working through old Mongoid issues on two bus rides. I kept going. The work expanded into new spelling tools in three languages, library features, CI maintenance, releases, and application upgrades. First, let's count what actually happened. Then let's talk about what these numbers mean, or don't. The Numbers These are ten calendar dates, October 14 through October 23, 2026, with a cutoff of October 23 at 1:32 p.m. Eastern. measure count what it means opened 295 authored by dblock repositories 49 includes forks merged 257 of the 295 opened still open 30 awaiting review or further work closed unmerged 8 includes superseded work and approaches I abandoned all prs merged 271 includes 14 older PRs releases 30 across 22 repositories issues opened 27 new work and follow-ups The complete PR inventory includes every title, repository, URL, status, and category. The release inventory includes all 30 release links. GitHub's authored PR search and merged PR search are useful receipts, although their results will keep changing. The Work I assigned every PR to one category based on its repository. This avoids counting a PR three times because it contains a bug fix, tests, and documentation. category opened merged open abandoned mongoid ecosystem 119 97 19 3 three new spelling tools 60 60 0 0 hashie 31 27 0 4 email libraries 26 26 0 0 danger and maintainer automation 19 17 2 0 upstream integrations, examples, and this blog 16 6 9 1 github issue action 13 13 0 0 bot application upgrades 11 11 0 0 total 295 257 30 8 The work itself fell into several different kinds of engineering: new features, bug archaeology, regression coverage, compatibility testing, performance, A

## Introducing Markdownlint Spellcheck

DevFeed: [Introducing Markdownlint Spellcheck](<https://devfeed.tech/articles/introducing-markdownlint-spellcheck-96431.md>)

Original publisher: [Read original article](<https://code.dblock.org/2026/10/22/introducing-markdownlint-rule-spellcheck.html>)

Author: Daniel Doubrovkine (dblock@dblock.org)

Published: 2026-10-22T00:00:00Z

Content type: release

Language: en

Sources: [Daniel Doubrovkine](<https://devfeed.tech/sources/daniel-doubrovkine.md>)

Topics: [Documentation](<https://devfeed.tech/topics/documentation.md>), [npm](<https://devfeed.tech/topics/npm.md>), [npm packages](<https://devfeed.tech/topics/npm-packages.md>)

Tags: [blog](<https://devfeed.tech/tags/blog.md>), [command-line](<https://devfeed.tech/tags/command-line.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [documentation](<https://devfeed.tech/tags/documentation.md>), [english](<https://devfeed.tech/tags/english.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [jekyll](<https://devfeed.tech/tags/jekyll.md>), [liquid](<https://devfeed.tech/tags/liquid.md>), [markdown](<https://devfeed.tech/tags/markdown.md>), [node-js](<https://devfeed.tech/tags/node-js.md>), [npm](<https://devfeed.tech/tags/npm.md>), [npx](<https://devfeed.tech/tags/npx.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [ruby](<https://devfeed.tech/tags/ruby.md>), [rust](<https://devfeed.tech/tags/rust.md>), [technical-documentation](<https://devfeed.tech/tags/technical-documentation.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

markdownlint-rule-spellcheck 0.1.0 adds CSpell-powered spelling checks to Markdown through markdownlint-cli2, requires Node.js 22.18 or later, and includes American English without a separate dictionary or system spelling package. It checks headings, paragraphs, lists, tables, link labels, image descriptions, and--by default--YAML front matter; it skips code, links' destinations, URLs, email addresses, and Liquid tags and expressions. Project vocabulary can be collected, reviewed for typos, and added to a custom dictionary. Autocorrection is opt-in and only applies when the first suggestion is one edit away; the excerpt recommends reviewing changes because a correctly spelled suggestion may still be the wrong word. Checking front matter requires a markdownlint-cli2 setting that leaves it visible to custom rules, which can also expose it to other Markdown rules, or front matter checking can be disabled.

### Source excerpt

After RuboCop spelling checks for Ruby and Dylint spelling checks for Rust, here's the version that doesn't require either language's toolchain. Introducing markdownlint-rule-spellcheck, a custom markdownlint rule powered by CSpell. Released 0.1.0 checks Markdown prose, suggests corrections, and ships American English through its dependencies. No separate dictionary download or system spelling package is required. Getting Started Requires Node.js 22.18 or later. Install the rule and the command-line runner: npm install --save-dev markdownlint-cli2 markdownlint-rule-spellcheck@0.1.0 Add .markdownlint-cli2.jsonc: { "customRules": ["markdownlint-rule-spellcheck"] } Given example.md: # Say helo to the world Run: npx markdownlint-cli2 example.md The spelling diagnostic includes the original line and column: example.md:1:7 error spellcheck Prose words should be spelled correctly [Misspelled word: "helo". Suggestions: hello, helio, halo.] Headings, paragraphs, lists, tables, link labels, and image descriptions are checked. Code, link destinations, URLs, and email addresses are skipped. Liquid expressions and tags are skipped too, which matters for Jekyll sites like this one. Accepting Project Vocabulary Technical documentation contains legitimate words that aren't in an English dictionary. Collect candidates, review them, and add the accepted words: npx markdownlint-rule-spellcheck collect "**/*.md" --output .spellcheck.txt # Edit .spellcheck.txt: remove actual typos. npx markdownlint-rule-spellcheck add ./.spellcheck.txt npx markdownlint-cli2 "**/*.md" The add command updates .markdownlint.json, preserving existing settings. Its dictionary configuration looks like this: { "spellcheck": { "dictionaries": { "en": ["@cspell/dict-en_us", "./.spellcheck.txt"] } } } Corrections and Front Matter Corrections are opt-in. Set "autocorrect": true inside spellcheck, then run: npx markdownlint-cli2 --fix "**/*.md" The first suggestion must be one edit away: an insertion, deletion, sub

## Introducing Dylint Spellcheck (Rust)

DevFeed: [Introducing Dylint Spellcheck (Rust)](<https://devfeed.tech/articles/introducing-dylint-spellcheck-rust-95041.md>)

Original publisher: [Read original article](<https://code.dblock.org/2026/10/22/introducing-dylint-spellcheck.html>)

Author: Daniel Doubrovkine (dblock@dblock.org)

Published: 2026-10-22T00:00:00Z

Content type: release

Language: en

Sources: [Daniel Doubrovkine](<https://devfeed.tech/sources/daniel-doubrovkine.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [Markdown](<https://devfeed.tech/topics/markdown.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [0-1](<https://devfeed.tech/tags/0-1.md>), [added](<https://devfeed.tech/tags/added.md>), [all](<https://devfeed.tech/tags/all.md>), [comment](<https://devfeed.tech/tags/comment.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [english](<https://devfeed.tech/tags/english.md>), [examples](<https://devfeed.tech/tags/examples.md>), [feature](<https://devfeed.tech/tags/feature.md>), [getting-started](<https://devfeed.tech/tags/getting-started.md>), [git](<https://devfeed.tech/tags/git.md>), [github](<https://devfeed.tech/tags/github.md>), [idea](<https://devfeed.tech/tags/idea.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [install](<https://devfeed.tech/tags/install.md>), [mcp](<https://devfeed.tech/tags/mcp.md>), [metadata](<https://devfeed.tech/tags/metadata.md>), [nightly](<https://devfeed.tech/tags/nightly.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [rust](<https://devfeed.tech/tags/rust.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

dylint-spellcheck adds spelling linting for Rust comments, Rustdoc attributes, Markdown, and plain text. It uses Kotoshu and bundles an American English dictionary. Install Dylint with the specified stable Cargo command, add the library's Git tag to workspace metadata, and run `cargo +stable dylint --all`; Dylint builds the library with its pinned nightly without changing the application's toolchain or adding an application dependency. In excalc-rs, a workspace `dylint.toml` combines bundled English with `.spellcheck.txt` to accept technical vocabulary. The author checked both default and no-default feature configurations, reviewed and committed a sorted, deduplicated vocabulary of 136 case-sensitive entries, then configured CI to fail on warnings. The supplied text ends during the integration account, so it does not establish further results.

### Source excerpt

After adding spelling checks to RuboCop, I wanted the same thing for Rust. Introducing dylint-spellcheck, a Dylint library for checking spelling in Rust comments, Rustdoc attributes, Markdown, and plain text. It uses the Rust implementation of Kotoshu and ships an American English dictionary. The idea is the same as the Ruby version: fix actual typos, accept project-specific vocabulary, and run spelling alongside the other lint checks. Getting Started The examples below use released 0.1.0. Install Rust through rustup, then install Dylint: cargo +stable install cargo-dylint dylint-link --version 6.2.0 --locked Add the library to your project's Cargo.toml: [workspace.metadata.dylint] libraries = [ { git = "https://github.com/dblock/dylint-spellcheck", tag = "v0.1.0" }, ] Dylint libraries are distributed through Git. Dylint downloads and builds this one with its pinned nightly compiler without changing the application's normal toolchain. There is no crate to add to your application's dependencies. Run it: cargo +stable dylint --all Given this Rust comment: // The red brown fox jumsp over the lazy dog. fn main() {} Dylint reports: warning: misspelled word: `jumsp` --> src/main.rs:1:22 | 1 | // The red brown fox jumsp over the lazy dog. | ^^^^^ | = help: did you mean `jump`, `jumps`, `lump`? = note: `#[warn(spellcheck)]` on by default Implementation in excalc-rs I added spell-checking to excalc-rs in PR #4. Technical comments contain perfectly legitimate words that are not in an English dictionary: Kronrod, Mascheroni, MCP, and excalc, for example. I added a workspace-root dylint.toml to combine bundled English with a project vocabulary: [dylint-spellcheck] dictionaries = ["crate:dylint-spellcheck/data/en", ".spellcheck.txt"] The crate: reference selects dictionary resources, not another application dependency. Bundled English is available without downloading a separate dictionary. With .spellcheck.txt absent, I ran the full intended feature scope: cargo +stable dylint -

## Introducing RuboCop Spellcheck

DevFeed: [Introducing RuboCop Spellcheck](<https://devfeed.tech/articles/introducing-rubocop-spellcheck-93012.md>)

Original publisher: [Read original article](<https://code.dblock.org/2026/10/21/introducing-rubocop-spellcheck.html>)

Author: Daniel Doubrovkine (dblock@dblock.org)

Published: 2026-10-21T00:00:00Z

Content type: tutorial

Language: en

Sources: [Daniel Doubrovkine](<https://devfeed.tech/sources/daniel-doubrovkine.md>)

Topics: [Tool](<https://devfeed.tech/topics/tool.md>), [Python](<https://devfeed.tech/topics/python.md>), [code comments](<https://devfeed.tech/topics/code-comments.md>), [Markdown](<https://devfeed.tech/topics/markdown.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [backend](<https://devfeed.tech/tags/backend.md>), [blog](<https://devfeed.tech/tags/blog.md>), [comment](<https://devfeed.tech/tags/comment.md>), [development](<https://devfeed.tech/tags/development.md>), [easy](<https://devfeed.tech/tags/easy.md>), [english](<https://devfeed.tech/tags/english.md>), [environment](<https://devfeed.tech/tags/environment.md>), [example](<https://devfeed.tech/tags/example.md>), [examples](<https://devfeed.tech/tags/examples.md>), [false-positives](<https://devfeed.tech/tags/false-positives.md>), [first](<https://devfeed.tech/tags/first.md>), [generate](<https://devfeed.tech/tags/generate.md>), [getting-started](<https://devfeed.tech/tags/getting-started.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [install](<https://devfeed.tech/tags/install.md>), [linting](<https://devfeed.tech/tags/linting.md>), [markdown](<https://devfeed.tech/tags/markdown.md>), [meaning](<https://devfeed.tech/tags/meaning.md>), [minutes](<https://devfeed.tech/tags/minutes.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [ruby](<https://devfeed.tech/tags/ruby.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

rubocop-spellcheck brings spelling checks into RuboCop for Ruby comments, strings, identifiers, Markdown, RDoc, AsciiDoc, and plain text. Version 0.2.0 uses Kotoshu's pure Ruby backend and includes an American English dictionary, with no separate spelling package required. Add the gem to the development group, enable the plugin, and run the Spellcheck/Spelling cop. Its optional `-A` autocorrection can fix cases such as the adjacent transposition `jumsp` to `jumps`; it leaves all-caps, mixed-case, and dotted technical tokens alone. Because unsafe corrections can alter meaning or names, review the diff. Remaining false positives can be stored in `.spellcheck.txt`, but generated entries also suppress real typos, so review that list. The author reports an average of 3.69 seconds to check 618 tracked Markdown files over three runs with caching disabled.

### Source excerpt

I replaced this blog's Python spell checker that took more than three minutes to run with the new rubocop-spellcheck. I really love RuboCop for its standard approach to linting and auto-correction, which solves the difficult problem of deciding between tabs and spaces (use defaults). My typical implementation in Ruby projects is to add a standard .rubocop.yml, run rubocop -a, ask an AI to fix easy fixable violations, then run rubocop --auto-gen-config to mark all remaining ones as an exception. Why should spelling be any different? Introducing rubocop-spellcheck, a RuboCop plugin for checking spelling in Ruby comments, strings, identifiers, Markdown, RDoc, AsciiDoc, and plain text. It uses Kotoshu with its pure Ruby backend and ships an American English dictionary. No separate dictionary download, environment, or system spelling package is required. Getting Started The examples below use released 0.2.0. Add this to your Gemfile: group :development do gem 'rubocop-spellcheck', '~> 0.2.0', require: false end Enable the plugin in .rubocop.yml: plugins: - rubocop-spellcheck Run it: bundle install bundle exec rubocop --only Spellcheck/Spelling Given this Ruby comment: # The red brown fox jumsp over the lazy dog. RuboCop reports: example.rb:1:21: C: [Correctable] Spellcheck/Spelling: Misspelled word: jumsp. Did you mean jumps, jump, jumpy? # The red brown fox jumsp over the lazy dog. ^^^^^ Try auto-correct when the first suggestion is one edit away: bundle exec rubocop -A --only Spellcheck/Spelling This changes jumsp to jumps, an adjacent transposition, even though there are three suggestions. Corrections accept lowercase and title-case words, but leave ALL CAPS, mixed-case words, and dotted technical tokens alone. -A opts into unsafe changes: even a correctly spelled replacement can change the meaning of a comment or document, including people's names. Review the diff. Examine spelling mistakes and fix them. Then generate a .spellcheck.txt for remaining false positives s

## AI Wants to Eat Your Project Backlog

DevFeed: [AI Wants to Eat Your Project Backlog](<https://devfeed.tech/articles/ai-wants-to-eat-your-project-backlog-89789.md>)

Original publisher: [Read original article](<https://code.dblock.org/2026/10/15/ai-wants-to-eat-your-project-backlog.html>)

Author: Daniel Doubrovkine (dblock@dblock.org)

Published: 2026-10-15T00:00:00Z

Content type: opinion

Language: en

Sources: [Daniel Doubrovkine](<https://devfeed.tech/sources/daniel-doubrovkine.md>)

Topics: [Integration testing](<https://devfeed.tech/topics/integration-testing.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [superProductivity](<https://devfeed.tech/topics/superproductivity.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ci](<https://devfeed.tech/tags/ci.md>), [docker](<https://devfeed.tech/tags/docker.md>), [integration-test](<https://devfeed.tech/tags/integration-test.md>), [mongodb](<https://devfeed.tech/tags/mongodb.md>), [mongoid](<https://devfeed.tech/tags/mongoid.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [pr](<https://devfeed.tech/tags/pr.md>), [ruby](<https://devfeed.tech/tags/ruby.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

The author describes using Copilot to work through open-source project backlogs, with the agent handling implementation and testing while the author selected tasks, reviewed changes, and merged pull requests. Examples include adding integration tests for MongoDB sharding, modernizing CI, fixing bugs, and closing 81 issues across 17 repositories. A test attempt did not reproduce the reported locking problem, illustrating the need for human review of agent-produced work.

### Source excerpt

You can clear the backlog of your open-source projects with AI now. It's really great at reproducing bugs, implementing reasonable features, adding the tests you never had time to write, and responding to user issues that have been open forever. Copilot and I worked through a dozen projects in the Mongoid organization on two 4-hour bus rides to visit my son in college (go Lions!). I picked the work, questioned the implementations, reviewed the results, and merged changes. The agent did all the typing, archaeology, environment setup, and testing. The most satisfying result was an issue about MongoDB sharding that had been open since September 2013: mongoid-locker #19 reported that acquiring a lock failed on collections sharded by _id. The original discussion included "not sure how easy it will be to replicate that in a test environment". That is exactly the kind of issue that becomes permanent. You need a MongoDB configuration server, a shard, replica sets, a router, the right collection configuration, and enough understanding of all of them to know whether your test is testing anything. You also need to find the motivation to do this for somebody else's production problem. Copilot opened PR #112 in under four minutes. The result was a real sharded-cluster integration test. A Docker bootstrap started a configuration-server replica set, a shard replica set, and mongos. The tests checked that they were talking to the router, explicitly sharded a collection by ranged and hashed _id, and exercised lock acquisition, contention, expiration, release, and cleanup when the block raised an exception. CI ran the tests against MongoDB 6.0 and 8.0. The PR did not reproduce the problem, so PR #114 tried again with dependencies available when the issue was reported. That built Ruby 2.0.0p247 with MongoDB 2.4.6, Mongoid 3.1.0, and the published mongoid-locker 0.2.1. This time we used two shards and verified that each sharded collection actually had documents on both, rather than tru

## ELPDS: Inspecting FAT Partitions in 1995

DevFeed: [ELPDS: Inspecting FAT Partitions in 1995](<https://devfeed.tech/articles/elpds-inspecting-fat-partitions-in-1995-85048.md>)

Original publisher: [Read original article](<https://code.dblock.org/2026/10/11/elpds-a-1995-dos-disk-inspection-tool.html>)

Author: Daniel Doubrovkine (dblock@dblock.org)

Published: 2026-10-11T00:00:00Z

Content type: article

Language: en

Sources: [Daniel Doubrovkine](<https://devfeed.tech/sources/daniel-doubrovkine.md>)

Topics: [Disk image](<https://devfeed.tech/topics/disk-image.md>), [NVS Encryption](<https://devfeed.tech/topics/nvs-encryption.md>), [GitHub Copilot CLI](<https://devfeed.tech/topics/github-copilot-cli.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [copilot](<https://devfeed.tech/tags/copilot.md>), [dos](<https://devfeed.tech/tags/dos.md>), [github-copilot-cli](<https://devfeed.tech/tags/github-copilot-cli.md>), [licensing](<https://devfeed.tech/tags/licensing.md>), [linux](<https://devfeed.tech/tags/linux.md>), [nostalgia](<https://devfeed.tech/tags/nostalgia.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [partitions](<https://devfeed.tech/tags/partitions.md>)

### AI overview

The author recovered ELPDS, a 1995 DOS utility that reports disk geometry, partition entries, FAT boot-sector details, and free space without changing the disk. Comparing it with FIPS source revealed nearly identical parsing and geometry routines. A separate DOS port was made with GitHub Copilot CLI and Open Watcom, tested in DOSBox-X on a FAT16 disk image. The tool is intended for old DOS disks, and the article explains that ELPDS is GPL version 2 or later because FIPS was.

### Source excerpt

I recovered another program I wrote in 1995: ELPDS, or Enhanced Logical & Physical Drive Status. Run ELPDS C: and it reports physical disk geometry, partition entries, FAT boot-sector details, and free space. It doesn't change anything on the disk. My help says it was for checking whether a partition existed and was formatted. I think I was just trying to learn about the underlying partition mechanics. I didn't write all of it. The help credits "Mr. Schaeffer" for a "huge part of FIPS code." That was Arno Schaefer, whose name I misspelled. FIPS could split a FAT partition without deleting its files, often to make room for Linux. Its original project page and Berkeley project page are archived. Comparing my code with the archived FIPS source found nearly identical boot-sector parsing, disk geometry routines, and even comments. I had turned its disk-reading machinery into a standalone status tool. GitHub Copilot CLI and I made a separate DOS port using Open Watcom, leaving the original source and executable unchanged. It runs in DOSBox-X against a disposable FAT16 disk image: 16 heads, 63 sectors per track, 65 cylinders, and about 32 MiB. We fixed decoding and error handling, but this is still a tool for old DOS disks, not modern ones. The source, port, and build instructions are on GitHub. FIPS was GPL version 2 or later, so ELPDS is too. Thirty-one years later, I finally got the author's name and the license right. ELPDS: Inspecting FAT Partitions in 1995 was originally published by Daniel Doubrovkine at code.dblock.org | tech blog on October 11, 2026.

## A 1998 PDF-to-Text Converter

DevFeed: [A 1998 PDF-to-Text Converter](<https://devfeed.tech/articles/a-1998-pdf-to-text-converter-84490.md>)

Original publisher: [Read original article](<https://code.dblock.org/2026/10/09/a-1998-pdf-to-text-converter.html>)

Author: Daniel Doubrovkine (dblock@dblock.org)

Published: 2026-10-09T00:00:00Z

Content type: article

Language: en

Sources: [Daniel Doubrovkine](<https://devfeed.tech/sources/daniel-doubrovkine.md>)

Topics: [Parser](<https://devfeed.tech/topics/parser.md>), [plist](<https://devfeed.tech/topics/plist.md>), [ClojureScript](<https://devfeed.tech/topics/clojurescript.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [GitHub Copilot CLI](<https://devfeed.tech/topics/github-copilot-cli.md>), [xz](<https://devfeed.tech/topics/xz.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [commands](<https://devfeed.tech/tags/commands.md>), [github-copilot-cli](<https://devfeed.tech/tags/github-copilot-cli.md>), [hash-table](<https://devfeed.tech/tags/hash-table.md>), [nostalgia](<https://devfeed.tech/tags/nostalgia.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [parsing](<https://devfeed.tech/tags/parsing.md>), [zlib](<https://devfeed.tech/tags/zlib.md>)

### AI overview

The author recovered a 1998 C++ PDF parser written for a search engine and ported it to C++17 with help from GitHub Copilot CLI. The parser handles PDF versions 1.0 through 1.2 by following cross-reference offsets and object references, and the updated port fixes several stream and text-handling issues while retaining the original version limits.

### Source excerpt

In 1998 I needed to convert PDF files to text for a search engine called Alkaline, without requiring separately installed libraries. So I wrote a C++ parser. Alkaline is another story. I recovered the source from a backup dated December 26, 1998. It reads PDF 1.0 through 1.2, follows object references and page trees, decompresses content with bundled zlib, and prints metadata, page text and bookmark titles. There are my own string, vector and hash-table libraries in there too. The encryption code is a stub. This was a work in progress. I wasn't reverse engineering an undocumented format. Adobe had published the specification in 1993, and my comments refer to the PDF Reference, right down to a page number for stream filters. This predates tagged PDF, introduced in 2001. Getting text meant interpreting page drawing commands, not following a tagged reading order. I was very impressed by how clever the format was. You start near the end, find the cross-reference table, and use its byte offsets to jump straight to the objects you need. A page points to its content and resources, so the reader follows those references rather than parsing the whole file from beginning to end. You don't have to read the entire document to render one page. GitHub Copilot CLI and I made it build again as a C++17 port, keeping the parsing approach but replacing the old containers with the standard library and using system zlib. The original is preserved unchanged. The port fixes binary stream lengths, line endings and several text operators, but it still targets those old PDF versions. Don't point it at a modern PDF and expect miracles. The source and port are on GitHub, under the MIT license. A 1998 PDF-to-Text Converter was originally published by Daniel Doubrovkine at code.dblock.org | tech blog on October 09, 2026.

## UcsLink.Fusion: a 1997 tool for configuring university workstations

DevFeed: [UcsLink.Fusion: a 1997 tool for configuring university workstations](<https://devfeed.tech/articles/universal-copy-system-link-for-97-windows-pcs-64463.md>)

Original publisher: [Read original article](<https://code.dblock.org/2026/10/03/ucslink-fusion-configuring-university-workstations-in-1997.html>)

Author: Daniel Doubrovkine (dblock@dblock.org)

Published: 2026-10-03T00:00:00Z

Content type: article

Language: en

Sources: [Daniel Doubrovkine](<https://devfeed.tech/sources/daniel-doubrovkine.md>)

Topics: [configuration-management](<https://devfeed.tech/topics/configuration-management.md>), [rhel](<https://devfeed.tech/topics/rhel.md>), [ReactOS](<https://devfeed.tech/topics/reactos.md>), [Ubuntu](<https://devfeed.tech/topics/ubuntu.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [nostalgia](<https://devfeed.tech/tags/nostalgia.md>)

### AI overview

A retrospective on UcsLink.Fusion, a Delphi application written in 1997 to configure Windows and Linux university workstations. It used scripts to install shared software, apply settings, map drives, connect printers, and let users control optional tasks. The article also describes its archived code, a local demonstration in Wine, and which network operations remain unverified.

### Source excerpt

In 1997 I wrote UcsLink.Fusion for the University of Geneva. We had hundreds of PCs across the city, Sun and Windows NT servers, and Windows 95 and Linux workstations. Getting a user's software and settings onto whichever PC they sat down at was a job for login scripts. I wrote a Delphi 2.0 application to do it instead. UCS stood for Universal Copy System. Fusion read a script that mapped network drives, copied shared software, created shortcuts, connected printers, set environment variables and synchronized the clock. It could include other scripts, test conditions and clean up files left by a previous run. The surviving configuration maps a personal drive, a software drive and a group drive, then chooses printers based on the workstation's location. A user could disable optional software rather than wait for it to copy at every login, or install it later by double-clicking its icon. Administrators could make tasks mandatory and protect individual options. A tree showed the tasks and their settings; a second list showed what would run. User choices went into a personal profile, separate from the shared script. When Fusion started at login, it displayed the little progress window below, showing the tasks as it configured the workstation. Fusion could scan a shared software directory and automatically add each application it found to the list of available software. Each application could come with its own script describing how to install and configure it. Tasks normally ran one after another, but a detached option let copies or banners run concurrently. Later, server-generated "virtual" scripts grouped applications into one file to avoid dozens of slow network accesses. Fusion was released as public-domain software. It was also used at ITIC, the Instituto de Tecnologia da Informação e da Comunicação (Institute of Information and Communication Technology) at Universidade Santa Úrsula in Rio de Janeiro. Its archived history page says the institute was established on Ma

## File & Folder 98: a 1998 Word Document Manager

DevFeed: [File & Folder 98: a 1998 Word Document Manager](<https://devfeed.tech/articles/file-folder-98-a-1998-word-document-manager-62386.md>)

Original publisher: [Read original article](<https://code.dblock.org/2026/09/29/file-and-folder-98-a-1998-word-document-manager.html>)

Author: Daniel Doubrovkine (dblock@dblock.org)

Published: 2026-09-29T00:00:00Z

Content type: article

Language: en

Sources: [Daniel Doubrovkine](<https://devfeed.tech/sources/daniel-doubrovkine.md>)

Topics: [file](<https://devfeed.tech/topics/file.md>), [Process](<https://devfeed.tech/topics/process.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [build](<https://devfeed.tech/tags/build.md>), [file](<https://devfeed.tech/tags/file.md>), [files](<https://devfeed.tech/tags/files.md>), [manager](<https://devfeed.tech/tags/manager.md>), [nostalgia](<https://devfeed.tech/tags/nostalgia.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [port](<https://devfeed.tech/tags/port.md>), [product](<https://devfeed.tech/tags/product.md>), [scripts](<https://devfeed.tech/tags/scripts.md>), [tool](<https://devfeed.tech/tags/tool.md>), [volume](<https://devfeed.tech/tags/volume.md>), [volumes](<https://devfeed.tech/tags/volumes.md>), [windows](<https://devfeed.tech/tags/windows.md>), [word](<https://devfeed.tech/tags/word.md>)

### AI overview

The author recounts building File & Folder, a document manager for a small business, and its evolution from a Visual Basic app into File & Folder 98, rewritten in Delphi 3. The software organized Word documents in administrator-defined virtual volumes and supported common file operations and document previews.

### Source excerpt

In the 1990s I wrote a document manager for a small business in Geneva with about 20 workstations. Most of its staff were new to computers, and folders were a challenging idea to grasp. They saved Word documents wherever Word happened to put them, and the network supervisor spent his days looking for lost files by panicked coworkers. File & Folder solved that problem. My 1999 product page said it was for "a small business which is sick and tired of seeing it's workers putting documents a bit everywhere in the system." The first version, File & Folder 1.0, was a Visual Basic app for Windows 3.11. It sold as shareware for US$75. A 32-bit version for Windows 95 and NT, File & Folder 1.2, followed in 1996. It worked in one root folder with numbered subfolders, supposedly one per client or case number. You typed a number, and it listed the Word documents in that folder, or offered to create one. It drove Word over OLE automation to open and create documents. The source, the Word stand-in and the scripts to run it are on GitHub. In 1998 I attempted to generalize the idea and rewrote File & Folder from scratch in Delphi 3 as File & Folder 98. It replaced drives and directories with virtual volumes, simplifying the file system navigation into a layout that an administrator could choose. Under a volume, a folder held either documents or other folders, never both. Users created, opened, copied, moved and renamed Word documents within this one window, without needing to use the Word file dialogs. The tool also offered document previews. File & Folder 98's original source, the port, the build scripts are on GitHub. File & Folder 98: a 1998 Word Document Manager was originally published by Daniel Doubrovkine at code.dblock.org | tech blog on September 29, 2026.

## zBalls: a 1998 Java Applet

DevFeed: [zBalls: a 1998 Java Applet](<https://devfeed.tech/articles/zballs-a-1998-java-applet-62107.md>)

Original publisher: [Read original article](<https://code.dblock.org/2026/09/29/zballs-a-1998-java-applet.html>)

Author: Daniel Doubrovkine (dblock@dblock.org)

Published: 2026-09-29T00:00:00Z

Content type: article

Language: en

Sources: [Daniel Doubrovkine](<https://devfeed.tech/sources/daniel-doubrovkine.md>)

Topics: [Java](<https://devfeed.tech/topics/java.md>), [openjdk](<https://devfeed.tech/topics/openjdk.md>), [browser](<https://devfeed.tech/topics/browser.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [game](<https://devfeed.tech/tags/game.md>), [java](<https://devfeed.tech/tags/java.md>), [jdk](<https://devfeed.tech/tags/jdk.md>), [open-source](<https://devfeed.tech/tags/open-source.md>)

### AI overview

The author recalls creating Bolongas zBalls, a Java applet game, with a classmate in 1998. They describe its mouse-driven play and note that applets were removed in JDK 26; the game's source and playable version are linked.

### Source excerpt

In January 1998, a classmate and I wrote a game. It was called "Bolongas zBalls", and it was a Java applet. You click to start, then move the mouse, without clicking. Touch the dark ball to blow it up, and the next ball turns dark. Clear them all and the next level doubles the number of balls. Touch a plain ball and it spawns another one, so if you're sloppy, the balls multiply until you lose. Each level has a time limit. The intro music is the theme song from Capitaine Flam, the French version of the Japanese cartoon Captain Future, which aired on TF1 in 1981. I honestly don't remember why we used it, nor why the game is called "Bolongas". Applets were removed in JDK 26, which is a shame, because a gray box that froze your browser for ten seconds and then asked you to trust a stranger's code was clearly the future of the web. You can find the source on GitHub and play the game here. zBalls: a 1998 Java Applet was originally published by Daniel Doubrovkine at code.dblock.org | tech blog on September 29, 2026.

## Good Morning, Dave: the 1998 INET Conference Kiosk Launcher

DevFeed: [Good Morning, Dave: the 1998 INET Conference Kiosk Launcher](<https://devfeed.tech/articles/good-morning-dave-the-1998-inet-conference-kiosk-launcher-62106.md>)

Original publisher: [Read original article](<https://code.dblock.org/2026/09/29/good-morning-dave-the-1998-inet-conference-kiosk-launcher.html>)

Author: Daniel Doubrovkine (dblock@dblock.org)

Published: 2026-09-29T00:00:00Z

Content type: article

Language: en

Sources: [Daniel Doubrovkine](<https://devfeed.tech/sources/daniel-doubrovkine.md>)

Topics: [WINE](<https://devfeed.tech/topics/wine.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [copilot](<https://devfeed.tech/tags/copilot.md>), [open-source](<https://devfeed.tech/tags/open-source.md>)

### AI overview

The author revisits a Delphi 3 kiosk launcher built for Windows 95 PCs at INET '98 and describes porting it to Free Pascal and Lazarus with Copilot. The rebuilt application runs under Wine on macOS. The port required fixes to forms, embedded bitmaps, button rendering, thread initialization, socket components and password-dialog behavior.

### Source excerpt

In July 1998, the Internet Society held INET '98, "The Internet Summit", at Palexpo in Geneva. The University of Geneva provided about 250 computers for the conference, and I was a student there. I wrote much of the conference network's website, www.inet98.ch, and the launcher that ran on the public Windows 95 PCs instead of Explorer. The Inet 98 Launcher was a full-height bar on the left of the screen with a button for each installed application: Internet Explorer, Netscape, PC Pine, Telnet, WS-FTP and Office 95 and 97. I wrote it in Delphi 3. It showed a screen saver when a machine sat idle, reset itself, and could reboot the PC to return it to a clean state. It also had a remote-control server on TCP port 895. Staff could connect from anywhere on the network, type a password and send a message to a user, hide the bar, start the screen saver, or reboot the machine. A wrong password got "alarm has been activated, you are logged!". The right one got "Good morning dave!". This is the launcher running again today, under Wine on macOS. The buttons change icon on hover. The hidden -stats command asks for a password and shows the activity counters. A remote session then logs in. It gets the alarm on a wrong password and the greeting on the right one. Then it sends a message, hides and shows the bar, reads machine stats and starts the screen saver. The conference was also the first time I had access to a T1 line to the US. Once the machines were up and running, there wasn't much left for me to do, so I spent hours on IRC. I found the source of both recently. They're now at dblock/inet98. Building It Again I don't have Delphi 3, so with Copilot I ported the launcher to Free Pascal and Lazarus. It builds with the Windows version of the compiler and runs under Wine on macOS. Most of the work was in the details. The binary Delphi forms had to be converted to text. Several embedded bitmaps had headers that Delphi tolerated and Lazarus didn't. My button component drew into its

## The Second Life of Autoconf for MS-DOS

DevFeed: [The Second Life of Autoconf for MS-DOS](<https://devfeed.tech/articles/the-second-life-of-autoconf-for-ms-dos-61360.md>)

Original publisher: [Read original article](<https://code.dblock.org/2026/09/27/the-second-life-of-autoconf-for-ms-dos.html>)

Author: Daniel Doubrovkine (dblock@dblock.org)

Published: 2026-09-27T00:00:00Z

Content type: article

Language: en

Sources: [Daniel Doubrovkine](<https://devfeed.tech/sources/daniel-doubrovkine.md>)

Topics: [Assembly](<https://devfeed.tech/topics/assembly.md>), [Code](<https://devfeed.tech/topics/code.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [OpenAPI Specification](<https://devfeed.tech/topics/openapi.md>)

Tags: [assembly](<https://devfeed.tech/tags/assembly.md>), [copilot](<https://devfeed.tech/tags/copilot.md>), [programming](<https://devfeed.tech/tags/programming.md>), [vestris](<https://devfeed.tech/tags/vestris.md>), [x86](<https://devfeed.tech/tags/x86.md>)

### AI overview

The author recounts discovering and extending a DOS configuration utility called Autoconf after copying its assembly source from a 1991 French computer magazine. Decades later, scanned archives helped identify the original author, and the listings were transcribed and rebuilt under DOS with Copilot and JWasm.

### Source excerpt

Before GNU Autoconf generated configure scripts, there was a DOS program called Autoconf. It let you keep one CONFIG.SYS and one AUTOEXEC.BAT, then choose among boot configurations by pressing a key. You did not have to wait for a menu. The PC BIOS kept early keystrokes in its keyboard queue, so you could press a configuration letter before AUTOCONF.SYS had even loaded. When the driver finally ran, it found the key and continued immediately. I did not write the original. I copied its x86 assembly source by hand from a French computer magazine. It was the first assembly program I had ever seen and the first piece of code I compiled. I spent the next three or four years extending it into my first commercial product. For a long time I could not remember who had written that first version. I had thrown away the magazine, forgotten the issue, and lost the trail before old print archives became easy to search. Only now, with AI helping sift through a large collection of scanned SVM issues downloaded from Abandonware Magazines and the Internet Archive, was I able to find the seven pages I had copied. The Magazine The original Autoconf appeared in the November 1991 issue of Science & Vie Micro, number 88, on pages 227-233. The article, "La configuration idéale", was written by Julien Pommier and won the magazine's monthly programming contest, including a 2,000-franc prize. The seven pages contained the complete assembly listings for AUTOCONF.ASM and the 11-byte READCONF.COM, installation instructions, sample startup files, and the commands required to build everything with MASM, LINK, and EXE2BIN. I must have spent a week copying the listing without understanding what most of it did, correcting it character by character, and figuring out how to assemble it. I needed multiple boot configurations because I was tired of editing CONFIG.SYS whenever I wanted to play a game. Thirty-five years later, Copilot and I transcribed the listings again and built them under DOS with JWasm.

## Porting My 1996 Pascal/Delphi Calculator to Rust (CLI + MCP)

DevFeed: [Porting My 1996 Pascal/Delphi Calculator to Rust (CLI + MCP)](<https://devfeed.tech/articles/porting-my-1996-pascal-delphi-calculator-to-rust-cli-mcp-59546.md>)

Original publisher: [Read original article](<https://code.dblock.org/2026/09/24/porting-my-1996-pascal-calculator-to-rust.html>)

Author: Daniel Doubrovkine (dblock@dblock.org)

Published: 2026-09-24T00:00:00Z

Content type: article

Language: en

Sources: [Daniel Doubrovkine](<https://devfeed.tech/sources/daniel-doubrovkine.md>)

Topics: [Model Context Protocol](<https://devfeed.tech/topics/model-context-protocol.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [Command-line interface](<https://devfeed.tech/topics/cli.md>), [Code](<https://devfeed.tech/topics/code.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [App](<https://devfeed.tech/topics/app.md>), [Statistics](<https://devfeed.tech/topics/statistics.md>), [Windows](<https://devfeed.tech/topics/windows.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [app](<https://devfeed.tech/tags/app.md>), [calculator](<https://devfeed.tech/tags/calculator.md>), [cli](<https://devfeed.tech/tags/cli.md>), [copilot](<https://devfeed.tech/tags/copilot.md>), [mcp](<https://devfeed.tech/tags/mcp.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [porting](<https://devfeed.tech/tags/porting.md>), [rust](<https://devfeed.tech/tags/rust.md>)

### AI overview

The article describes porting a complex Pascal/Delphi expression calculator to Rust and exposing it as both a command-line tool and an MCP server. It covers the calculator's mathematical, statistical, financial, and numerical-integration capabilities, and its potential use by AI coding agents.

### Source excerpt

In his Rails World 2026 keynote DHH talks about one-shot apps built almost instantly with an agent as part of Omarchy. His canonical example is Omacalc, a dead simple calculator. It's a good demo and not a hard problem. Let's take it further and rewrite a more advanced calculator in Rust that we can also run as an MCP server, so an AI coding agent can outsource arithmetic to it instead of hallucinating a square root. In 1994 I wrote an expression evaluator for a lab assignment. It grew into Expression Calculator, a shareware Windows app I sold through a company I co-founded, Vestris Inc. In 1997 it got pressed onto a CD-ROM and sold 3,000 copies in Germany under the name Global Calculator. I made money and users wrote fan mail. This week, Copilot and I ported its Pascal/Delphi core to Rust as excalc-rs (crates.io), a CLI and MCP server, in under 24 hours. Both the port and the original are mathematical beasts. They can: Chain 12 comparison and logical/bitwise operators, and 12 arithmetic operators with correct precedence Fit 8 general/rounding functions and 7 statistics functions (mean, variance, standard deviation) Evaluate 36 standard math functions: trig, inverse trig, and hyperbolic variants, both in radians and degrees Answer 17 number theory questions: GCD/LCM, Fibonacci, primality, Mersenne and perfect numbers, Euler's totient Run 18 financial functions: NPV, IRR, loan payments, present/future value, depreciation schedules Numerically integrate anything via 7 quadrature methods (trapezoid, Simpson, Gaussian, and more) Compute 21 advanced/special functions: the Gamma and Beta functions, elliptic integrals, Fresnel integrals, the error function, dilogarithm, Dawson's integral, sine and cosine integrals Let's verify that Euler's Gamma function is the continuous extension of the factorial (Γ(n) = (n-1)!), and comes back essentially zero (floating-point noise from numeric integration): calc 'gamma(10) - 9!' # 0.000000054249539971351624 Γ(10) equals 9! to 7 decimal

## Using AI Effectively in Technical Writing

DevFeed: [Using AI Effectively in Technical Writing](<https://devfeed.tech/articles/using-ai-effectively-in-technical-writing-58905.md>)

Original publisher: [Read original article](<https://code.dblock.org/2026/09/23/using-ai-effectively-in-technical-writing.html>)

Author: Daniel Doubrovkine (dblock@dblock.org)

Published: 2026-09-23T00:00:00Z

Content type: article

Language: en

Sources: [Daniel Doubrovkine](<https://devfeed.tech/sources/daniel-doubrovkine.md>)

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [GitHub Copilot CLI](<https://devfeed.tech/topics/github-copilot-cli.md>), [AI Agent](<https://devfeed.tech/topics/ai-agent.md>), [GitHub Copilot](<https://devfeed.tech/topics/github-copilot.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agents-md](<https://devfeed.tech/tags/agents-md.md>), [ai](<https://devfeed.tech/tags/ai.md>), [blog](<https://devfeed.tech/tags/blog.md>), [coding](<https://devfeed.tech/tags/coding.md>), [github-copilot](<https://devfeed.tech/tags/github-copilot.md>), [github-copilot-cli](<https://devfeed.tech/tags/github-copilot-cli.md>), [technical](<https://devfeed.tech/tags/technical.md>), [technical-writing](<https://devfeed.tech/tags/technical-writing.md>)

### AI overview

The author describes using GitHub Copilot CLI to analyze existing blog posts and create a VOICE.md file that guides AI-assisted technical writing. The article recommends using AI for drafting, pattern collection, structure, and repetitive technical examples while retaining human authorship and verifying, fixing, and explaining generated content.

### Source excerpt

I write a lot, and I use AI a lot. But AI does not write my blog posts. Mostly. AI is useful for making some of my writing less tedious. Recently, I asked GitHub Copilot CLI to read a few dozen posts from this blog and derive a VOICE.md to assist my writing. The result is now checked into this repo and linked from AGENTS.md, so any AI agent working here gets the same reminder: this blog is authored by me, not by AI and the agent's job is to help me rather than pretend to be me. The useful and interesting part of VOICE.md was how it captured my weirdly specific patterns. Start with a real story, failure, command, bug, or piece of data. Say the opinion early. Provide examples, pull requests, commands, screenshots, numbers, links. Admit mistakes. Let short posts stay short. End quickly, use Russian jokes or a link. Technical writing is just like coding, but do not attempt to fully automate it. Be picky about words, punctuation, examples, and whether a sentence actually sounds like something you would say. Use AI to produce a flow or even a draft, to collect patterns, suggest structure, and do the boring, time-consuming work around technical reproductions or samples. When a post needs the same example in Ruby, Python, JavaScript, Go, Rust, PHP, C#, Java, Elixir, Swift, Objective-C, and Dart, have an agent generate the first pass then verify, fix, and explain the interesting parts. Using AI Effectively in Technical Writing was originally published by Daniel Doubrovkine at code.dblock.org | tech blog on September 23, 2026.

[Next page](<https://devfeed.tech/sources/daniel-doubrovkine.md?cursor=WyIyMDI2LTA5LTIzVDAwOjAwOjAwKzAwOjAwIiwgIjdmZDAyN2FjLTlkMjMtNDM5Ni1iNzExLTZmNWJkMzNjYWIyNSJd>)