CrumbDesk: AI Understands Cake Orders, But Doesn't Overstep to Run the Bakery

In the custom baking industry, order changes are practically a daily occurrence. A customer switching from a 500g cake to a 1kg one may seem like just a numerical adjustment, but it could leave a baker who's already prepped ingredients with wasted effort. Developer Rishabh Raj published an experimental project called CrumbDesk on Dev.to, combining local Gemma AI with a deterministic rule engine to try to answer a real-world question: what role should AI play in the order workflow?

Breaking Down the Problem: Order Changes Are Really About Trust and Authority

Traditional order systems faced with order changes either accept everything wholesale or require manual review. Raj's starting point is very concrete: once cake production has begun, ingredients and labor have already been invested, and a change involves recalculating costs, checking inventory, and adjusting delivery times. If AI makes the call directly, the risk is uncontrollable; if it's purely manual, efficiency can't keep up.

He submitted CrumbDesk during the second week of the Hacktoberfest Open Source AI Challenge, positioning it as a "Side Hustle" category project. The core tension: AI excels at understanding natural language orders, but business decisions must be overseen by humans.

Hacktoberfest Open Source AI Challenge Background

Hacktoberfest is an open source contribution event held every October by DigitalOcean, where participants earn rewards by submitting Pull Requests. In recent years, an added AI Challenge requires participants to deliver a working open source project on a given theme (such as Side Hustle, developer tools, sustainability, etc.) within a few weeks. CrumbDesk belongs to the second week's "Side Hustle" track, which focuses on "using AI to solve real pain points for solo entrepreneurs or small businesses."

This context explains CrumbDesk's design orientation: it doesn't pursue general capabilities or technical showmanship, but requires the project to be runnable, reproducible, and useful to real users within limited time. That's why Raj chose a combination of a mature open source model plus a lightweight rule library, rather than a self-trained model or complex architecture—which also makes the project more valuable as a reference, since other developers can directly adopt this pattern.

Architecture Design: Gemma Reads, Rules Decide

CrumbDesk uses a dual-track mechanism. The local Gemma model does only one thing: parse natural language orders sent by customers into structured fields, such as cake weight, flavor, pickup time, and special requests. It does not directly modify order status or trigger any production action.

What actually determines "can it be changed, and how" is a deterministic rule engine. Raj describes it as "keeping the baker in control." The rules preset hard constraints like the change window, ingredient loss thresholds, and capacity limits, and AI parsing results must pass these rule checks before proceeding to the next step.

This design means: AI can understand "change 500g to 1kg," but whether it's ultimately accepted depends on the business rules set by the baker, not the model's judgment.

What Is a Deterministic Rule Engine?

A deterministic rule engine is a type of system that extracts business decision logic from code and expresses it as explicit rules. Its core characteristic: given the same input, it always produces the same output, with no probabilistic judgment. Common implementations include decision tables, condition-action rules (if-then), and lightweight libraries like Drools and JSON Logic.

In CrumbDesk, the rule engine carries hard constraints such as "has the change window passed," "has ingredient loss exceeded the threshold," and "does current capacity allow inserting a new order." Unlike machine learning models, every judgment in a rule engine can be reviewed, unit tested, and audited line by line. For small and medium merchants, this means that when a customer questions "why was my change rejected," the shop owner can directly point to which rule was triggered, rather than facing a black-box model. This is also the core reason Raj chose to hand decision-making authority to rules.

Why Not Let a Large Model Decide Directly

In the article, Raj admits he deliberately limited AI's authority. There are three layers to the reason: local Gemma ensures data doesn't leave the device, suiting small merchants' sensitivity to privacy; deterministic rules make every decision traceable and explainable; and after separating responsibilities, model upgrades or replacements won't affect the stability of business processes.

This leads to a broader discussion: in small and medium business scenarios, AI's value is often not replacing decisions, but reducing the friction of information entry and understanding. CrumbDesk's trade-off is to apply intelligence to "reading" and keep authority in "rules."

Trade-offs Between Local Small Models and Cloud Large Models

Gemma is an open source model family released by Google, offering versions with parameter sizes ranging from 2B to 27B, and can run offline on ordinary laptops or even single-board computers using tools like Ollama and llama.cpp. Compared with large models that call cloud APIs, local deployment sacrifices some reasoning capability and context length in exchange for three benefits: data doesn't leave the device, no per-token billing cost, and usability when offline.

For small merchants like bakeries and flower shops, order text is usually only a few dozen to a few hundred characters, and fields are relatively fixed (weight, flavor, time, notes), so quantized models at the 2B-9B level are sufficient for structured extraction tasks. Raj's choice is based precisely on this judgment: the task difficulty isn't high, and privacy and cost are the real constraints. This trade-off pattern is becoming increasingly common in edge AI scenarios.

Experimental Takeaways: The Division of Labor Between AI and Rules

Looking back at the project, Raj validated a viable pattern—a local small model plus a lightweight rule engine is enough to handle medium-complexity tasks like order parsing. Local deployment of Gemma lowers API costs and makes offline scenarios possible. The rule engine covers business risk control needs with an extremely small amount of code.

This approach can be transferred to other small business scenarios: flower shops changing delivery addresses, restaurants changing menu quantities, handmade goods changing custom sizes. Wherever "understanding customer intent" and "deciding whether to execute" can be separated, the same architecture applies.

CrumbDesk's code has been open-sourced in the repository linked to the Dev.to article, making it a pragmatic starting point for developers who want to try local AI plus rule engines.

One-line Summary

CrumbDesk uses local Gemma to parse orders and a rule engine to safeguard decision authority, exploring the division of labor for AI in small businesses.

Paragraph Summary

Developer Rishabh Raj released the experimental project CrumbDesk during the Hacktoberfest Open Source AI Challenge, attempting to answer what role AI should play in the order workflow. The project uses a dual-track architecture: the local Gemma model is only responsible for parsing customers' natural language orders into structured fields, without directly modifying orders or triggering production; the actual order-change decision is made by a deterministic rule engine, with hard constraints preset in the rules such as the change window, ingredient loss thresholds, and capacity limits. Raj deliberately limited AI's authority for three reasons: local deployment ensures privacy, rule-based decisions are traceable, and separation of responsibilities means model upgrades don't affect business stability. This pattern can be transferred to scenarios like flower shops changing addresses, restaurants changing quantities, and handmade goods changing sizes, with the core value being to use intelligence for understanding and leave authority to rules.