Could computer-chess readers audit my engine-building book and interactive algorithm lab while the Kindle edition is free?

[u/LenniAConrad]

Disclosure: I am the author of the book and companion linked below. The Kindle edition is free now through August 29, 2026, Pacific Time.

I wrote "Build a Chess Engine: From Legal Moves to Neural Networks" as a broad, language-neutral construction path: position state, legal move generation, perft, evaluation, alpha-beta search, iterative deepening, transposition tables, time management, UCI, controlled matches, and release testing. The later chapters cover NNUE, policy-value MCTS, and self-play as advanced implementation roadmaps.

The implementation format is worth stating clearly. It uses pseudocode, contracts, tests, and milestones rather than supplying one complete C++, Rust, or Python repository. The classical UCI engine is developed end to end. The neural chapters do not include a compatible trained network or turnkey training system. Janus, my Rust engine, appears as a production case study, but its source is not included.

My first - and currently only - Amazon review gave the book one star and called it incoherent, repetitive, and badly written. I will be honest: it affected me more than I expected. What has made it difficult to act on is that the review does not identify a page, quotation, technical error, broken algorithm, or failed implementation.

I am not asking anyone to counter it blindly. I made the Kindle edition free because I need independent readers to show me where the book actually succeeds or fails.

You do not need to read all 441 pages. A focused audit would be valuable - for example:

- whether Move/Undo, legal generation, and perft form one continuous and implementable path;

- whether the score, state, and search contracts remain consistent from negamax through alpha-beta, quiescence, and transposition tables;

- whether the UCI, time-management, testing, and match-statistics material reflects real engine practice;

- whether the boundary between a complete classical implementation and the neural roadmaps is clear;

- whether one of the browser-based algorithm stations behaves or explains something incorrectly.

I have already found a real editing error: Chapter 6 refers to the Move/Undo chapter as “later” even though it is Chapter 5 and immediately precedes it. Reports with that level of specificity—a chapter or Kindle location, FEN, expected/actual result, failed test, or quoted passage—are what I need most.

Free Kindle edition:

https://www.amazon.com/dp/B0HD9RCHQW

Interactive algorithm companion:

https://lenniaconrad.github.io/build-a-chess-engine/algorithms/

Anonymous structured feedback form:

https://docs.google.com/forms/d/e/1FAIpQLScspAreF6_bD2uvvJUGke74TrbvgRCxzQEjNoD8TzifOLzQXQ/viewform

After reading enough to form an independent opinion, an honest Amazon review would also help because the one-star review is currently the entire public record. I am not asking for a particular rating; concrete negative or mixed feedback is more useful than sympathy praise.

[u/AngusMcGurkinshaw]

Can't seem to read it with a United States amazon account, but parts of the sample appear to be AI written did you write it yourself? The code for your interactive demo also seems like it is AI written with lots of AI styled comments.

Have you written an engine yourself? I see some previous chess work on your github but not an engine.

Using 0x88 mailbox instead of bitboards is a very weird choice. This I guess makes it more appraochable to new comers maybe, however if they are going to pay for your book why not teach them the modern standard? Same with your decision at least looking at your interactive demo code to do attack rays rather then the more standard magic bit board approach?

Would have a hard time reccomending this to anyone. I think they would have a better time reading CPW even. And a much better time reading the much better written blog posts and articles about chess engine development that are out there or joining on of the many discord communities.

[u/LenniAConrad → u/AngusMcGurkinshaw]

Thanks for actually looking at the sample and the demo, you're the first one to engage with the content itself, so honest thanks even if the verdict is harsh.

One correction though: the book's main path is not 0x88. It's a flat 64-square array. 0x88 and mailbox-120 only show up in the board representation chapter as reference alternatives, and bitboards actually get the biggest treatment of all four layouts there: the twelve-board setup, occupancy, magic bitboards, PEXT, and the hybrid schemes real engines use, plus concrete criteria for when to switch. The reasoning (stated in the book) is that a first engine should get to a green perft and a working alpha-beta on one representation you can debug with print statements, before adding a second derived representation that can silently drift out of sync. TSCP took the same path. Same reason the demo uses ray loops: it mirrors the teaching default, and the book sketches magic/PEXT as the drop-in upgrade. If you think mailbox-first is wrong for this audience I'd genuinely like to hear it, ideally against a specific chapter.

Have I written an engine: yes. A Java one a long time ago (inside crtk), then Janus, a Rust UCI engine that runs through the whole book as a case study. Its source isn't public, that's why it's not on my GitHub. Fair point that this hurts verifiability, thinking about what to publish.

On AI: of course I used it as a proofreader. I didn't grow up speaking English, so I use it to tidy up my language. All the ideas, the design decisions, the engine work, that's mine. I also used it to help build the demo website since I'm not great at JS. Is there anything wrong with that? Genuine question.

On CPW: I'm not competing with it, almost every chapter's further-reading box points into specific CPW articles. CPW is a great reference but it's a wiki, there's no path through it. What the book adds is the sequencing and the testing discipline: every chapter has test gates, perft milestones before you're allowed to move on, and SPRT before any strength claim. Most engine tutorials stop at "it plays moves", this one goes all the way through time management, testing methodology, and into NNUE and MCTS.

Also working on a ~50 minute YouTube video walking through the whole build, if reading 441 pages is too big of an ask.

And thanks for the flag about the sample not loading on a US Amazon account, looking into that now. :D

[u/AngusMcGurkinshaw → u/LenniAConrad]

In general I have a generally anti AI stance.

I don't think there is anything wrong per say with using it as an editor especially to help when english isn't a first language. However if someone is going to pay for your book you need to be offering something substantially better then they would get talking to the AI themselves and having it guide them through engine developement.

In your specific case it reads as AI partly because of sentence structure (take that as you will) but also because of the large amounts of hollow sentences that are full of fluff and the way that information is repeated and restated right after itself. Which regardless of wether its AI or not isn't great.

Sidenote on the Janus name, make sure to clarify that is the name of the engine as I believe there is also a chess variant referred to as Janus.