DEV Community: Neuhaus Barsuhn

A Measurement-First Workflow for Evaluating AI Interior Concepts

Neuhaus Barsuhn — Sun, 30 Aug 2026 02:52:40 +0000

A Measurement-First Workflow for Evaluating AI Interior Concepts

AI image systems can produce an attractive room concept in seconds, but a concept image is not a construction drawing or a shopping list. The difficult engineering problem begins after generation: translating pixels into a plan that respects dimensions, circulation, daylight, services, budget, and the objects a household already owns. This workflow treats an AI concept as a visual hypothesis and tests assumptions before money is spent.

The method works without a full CAD stack. A measured sketch, a spreadsheet, and a consistent review sequence are sufficient for many early decisions.

1. Define the input contract

Start with a compact room brief rather than an open-ended request. Record the room type, primary activities, number of regular users, items that must remain, preferred mood, and a realistic budget band. Include constraints that cannot be inferred from a photograph: rental restrictions, pets, children, accessibility needs, and planned electrical equipment.

The brief should separate requirements from preferences. “Keep an 850 mm clear route from the door to the window” is a requirement. “Use a warm neutral palette” is a preference. This distinction matters when a generated concept looks appealing but forces a trade-off. Requirements fail the concept; preferences can be adjusted.

A structured input object can be represented as:

{
  "room": "living room",
  "users": 3,
  "must_keep": ["sofa", "bookcase"],
  "required_clearance_mm": 850,
  "budget_band": "moderate",
  "rental": true,
  "style": ["warm", "minimal", "natural wood"]
}

2. Capture a dependable measurement model

Measure wall lengths, ceiling height, doors, windows, radiators, outlets, switches, and fixed joinery. Record door swing and the height of window sills. Photograph every wall straight on as well as from the room corners. A photograph alone cannot reliably establish scale because wide-angle lenses distort distance and object size.

Create a simple coordinate system with one corner as (0, 0). Store fixed features as wall-relative intervals. For example, a window on the north wall might begin 920 mm from the west corner, have a width of 1,450 mm, and a sill height of 780 mm. This representation makes conflicts visible even in a spreadsheet.

Repeat any critical measurement twice. If the sum of wall segments does not match the total wall length, resolve the discrepancy before evaluating furniture placement. Small errors compound when several objects share one wall.

3. Generate alternatives, not a single answer

A useful generation pass should vary one major variable at a time. Keep geometry and required objects stable while producing alternatives for layout, lighting emphasis, material palette, or storage strategy. Comparing images that change every variable simultaneously makes it impossible to identify which choice improved the room.

Label each output with the prompt version and a short hypothesis. Examples include “layout A: conversation focus,” “layout B: media focus,” and “layout C: flexible work zone.” Preserve rejected concepts. They provide evidence about recurring failure modes and prevent a team from rediscovering the same unsuitable option later.

When using an interiordesign ai workflow, the generated scene should be treated as a reference layer. The target URL can help produce and compare visual directions, but dimensional acceptance still belongs to the measurement model.

4. Run a scale audit

For each concept, identify at least three visible reference objects with approximately known dimensions: a standard door, the retained sofa, a floorboard width, or an existing cabinet. Estimate whether generated furniture remains plausible relative to those references. Watch for common image-generation errors such as impossible chair depth, compressed doors, oversized pendant lights, or shelving that changes width along a wall.

Move candidate furniture into the measured sketch using manufacturer dimensions or conservative placeholders. Do not use the apparent image proportions as final values. For unknown products, use a range rather than a single estimate. A lounge chair might occupy between 800 × 800 mm and 950 × 1,000 mm. Test the larger footprint first.

A concept fails the scale audit if required objects cannot fit without reducing mandatory clearance, blocking a door swing, or overlapping fixed services.

5. Test circulation as a graph

Model important locations as nodes: entrances, seats, storage, work surfaces, windows, and frequently used equipment. Paths between them form the circulation graph. A successful layout keeps high-frequency paths direct and avoids forcing movement through active work zones.

Check clear widths at the narrowest point, not the average point. Include the space needed to pull out a chair, open a drawer, and turn around near a door. For mixed-use rooms, test simultaneous states. A dining table that works only when every chair is pushed in is not a robust plan.

It is helpful to annotate each edge with a frequency and minimum width:

entry -> sofa        daily-high     850 mm
sofa -> balcony      daily-medium   800 mm
entry -> storage     daily-high     900 mm
workdesk -> outlet   service        unobstructed

Prioritize the highest-frequency failures first. Decorative alignment should not override a safe, comfortable route.

6. Audit light by time and task

Generated images often depict idealized light without regard to orientation or time. Record window direction, nearby obstructions, and the periods when each task occurs. Separate ambient, task, and accent lighting. A visually dramatic pendant does not replace task light at a desk or reading chair.

Make a small matrix with rows for activities and columns for morning, afternoon, and evening. Note daylight availability, glare risk, and required artificial light. Evaluate screen reflections and strong contrast around televisions or monitors. Where exact simulation is unnecessary, this qualitative matrix still catches most obvious conflicts.

Treat color temperature as a system decision. Mixing unrelated lamp temperatures can make materials appear inconsistent. Test proposed colors under both daylight and the actual lamps intended for the room.

7. Validate storage and behavior

Storage capacity should be tied to an inventory rather than an image. List categories, approximate volume, access frequency, and whether items should be visible. Everyday objects need low-friction access. Seasonal items can occupy higher or deeper zones.

A concept may show perfectly styled shelves while omitting cables, chargers, cleaning tools, toys, paperwork, or media equipment. Add those categories to the plan. Check ventilation around electronics and access to outlets. Include a cable route before selecting closed cabinetry.

Behavior matters as much as capacity. If a household consistently drops keys and bags near the entrance, the redesign should provide a landing zone there instead of relying on a distant cabinet. A technically adequate storage volume in the wrong location will not remain organized.

8. Build an implementation dependency map

Convert accepted decisions into tasks and dependencies. Electrical changes, wall repair, painting, flooring, fixed joinery, and loose furniture usually have a natural order. Identify lead-time products and decisions that block later work.

For each task, record owner, estimate, prerequisite, and rollback cost. A reversible change such as moving a floor lamp can be tested early. A custom built-in or new outlet has a higher rollback cost and deserves stronger evidence.

confirm layout -> confirm outlet plan -> electrical work
confirm palette -> sample paint -> approve in room -> paint walls
confirm dimensions -> shortlist sofa -> verify access route -> order

This map prevents a polished concept from becoming an unstructured shopping sequence.

9. Prototype before commitment

Use painter’s tape to mark furniture footprints and circulation lines on the floor. Build cardboard mock-ups for tall or bulky objects. Live with the arrangement for several days when possible. Observe actual routes, daylight, noise, and where objects accumulate.

Order material samples and view them in the room at multiple times. Screen colors are not dependable for paint, fabric, timber, or stone. Test cleaning and maintenance requirements, especially for high-touch surfaces and households with children or pets.

Record changes from the AI concept in a decision log. Each entry should state the issue, evidence, chosen adjustment, and date. This creates a reusable dataset for future prompts and reduces repeated mistakes.

Conclusion

AI interior imagery is most valuable when it accelerates exploration without replacing measurement and verification. A robust process begins with a structured brief, captures geometry, generates controlled alternatives, and then tests scale, circulation, lighting, storage, dependencies, and cost. The final output is not a picture; it is a set of decisions with evidence, dimensions, and an implementation order.

The workflow also creates useful feedback for product teams. Repeated scale failures suggest better constraint inputs. Recurring lighting conflicts suggest orientation metadata. Frequent storage omissions suggest inventory fields. By treating each concept as a testable hypothesis, visual generation becomes part of a disciplined planning system rather than a shortcut around it.

Designing Responsible Adult Autism Self-Assessment Experiences

Neuhaus Barsuhn — Sun, 30 Aug 2026 01:10:54 +0000

Self-assessment tools sit at an unusual intersection of interface design, measurement, privacy, and human emotion. A visitor may arrive with a practical question, but the answers can carry personal meaning. That makes the design of the experience just as important as the questionnaire itself.

This article outlines a measurement-aware approach to adult autism self-assessment: how to create a flow that supports reflection while staying clear about what a screening result can and cannot establish.

1. Start with the purpose, not the score

A screening questionnaire is useful because it organizes observations. It can help someone notice recurring patterns in social communication, sensory experience, focused interests, routines, and the effort involved in navigating everyday environments.

The interface should explain that purpose before the first question. Users need to know that the result is informational, not a diagnosis. This framing is not merely a disclaimer; it changes how people interpret every later interaction.

A good introduction answers three questions:

What does this questionnaire measure?
How should the result be interpreted?
What are reasonable next steps after completion?

2. Reduce avoidable cognitive load

Long questionnaires can become tiring. Clear visual hierarchy, predictable controls, readable spacing, and visible progress reduce effort that is unrelated to the questions themselves.

Useful patterns include one decision at a time, consistent response order, plain language, keyboard-friendly controls, and a progress indicator that does not create pressure. Error states should be specific and calm. If answers are saved locally or transmitted, that should be stated in direct language.

The goal is not to make every question effortless. It is to remove interface friction so that attention stays on thoughtful responses.

3. Interpret patterns, not only totals

A total score is compact, but it can hide the most useful information. People often benefit more from reviewing clusters of responses and concrete examples from different stages of life.

A result page can encourage users to consider:

which themes have been consistent over time;
which situations make traits more or less noticeable;
whether masking or learned coping strategies affect presentation;
which patterns create difficulty, and which are simply differences;
what accommodations or support would improve daily life.

The RAADS R Test is one example of a private online flow that presents the questionnaire as a starting point for reflection. Its result should be considered alongside developmental history, current context, and professional evaluation when appropriate.

4. Treat privacy as part of usability

Sensitive self-assessment data deserves a minimal-data mindset. Collect only what is necessary, explain retention clearly, and avoid forcing account creation when it adds no value to the user.

Privacy language should appear at the moment it matters rather than being hidden in a distant policy. If results stay in the browser, say so. If information is sent to a server, explain why. Users should be able to leave the experience without ambiguity about what was stored.

This clarity builds trust and also improves answer quality: people can respond more thoughtfully when they understand the data boundary.

5. Offer grounded next steps

A responsible result screen avoids both alarm and false reassurance. It can suggest recording concrete examples, learning from autistic adults, discussing support needs with trusted people, or consulting a qualified clinician familiar with adult and masked presentations.

Not every user needs the same next step. Some may simply gain language for longstanding experiences. Others may seek accommodations or a formal assessment. The interface should support that range without claiming certainty it cannot provide.

A practical design checklist

Before publishing a self-assessment experience, review it against a short checklist:

The purpose and limitations are visible before participation.
Questions and controls are accessible and consistent.
Progress is clear without being coercive.
Privacy and retention are explained in plain language.
Results emphasize patterns and context, not only a number.
Next steps are practical, proportional, and non-diagnostic.
Crisis or urgent-care guidance is provided where the subject requires it.

Closing thought

Responsible self-assessment design does not remove uncertainty. It helps people work with uncertainty more carefully. When measurement limits, privacy boundaries, and next steps are explicit, a questionnaire can become a useful reflection tool rather than an overconfident verdict.

Building a Verification Pipeline for AI-Assisted Math Solutions

Neuhaus Barsuhn — Sat, 29 Aug 2026 12:27:45 +0000

Mathematics assistants are useful when they reduce the mechanical burden of a problem without hiding the reasoning. They can transcribe an equation from an image, propose a substitution, expand an expression, or generate a first draft of a proof. The difficult part is not producing a plausible sequence of symbols. The difficult part is deciding whether every transformation preserves the original problem.

For developers, students, and technical writers, this is a familiar engineering problem: an unverified output should not be promoted directly to a trusted result. It should pass through a pipeline of explicit checks. This article describes a practical verification pipeline for algebra, geometry, calculus, probability, and word problems. The workflow is deliberately tool-independent, so it can be used with a notebook, a command-line script, or a browser-based math ai assistant.

1. Preserve the Original Input

Before solving anything, save an exact representation of the prompt. For typed problems, copy the full statement, including constraints and units. For an image, keep the original image and write a separate transcription. Do not silently replace a symbol that looks unusual. A handwritten 1 can resemble l, a minus sign can resemble a fraction bar, and an exponent can be mistaken for a coefficient.

Treat transcription as its own stage with its own output. A useful record contains:

the original prompt or image;
the interpreted mathematical expression;
every ambiguity that was resolved;
assumptions about notation, domains, and units.

This separation makes later diagnosis much easier. If a final answer is wrong, you can determine whether the failure came from reading the problem, selecting a method, or executing the method.

2. Define a Contract for the Answer

A solver should know what a valid answer must look like before attempting to produce one. Think of this as an output contract. If the question asks for real solutions, complex roots do not satisfy the contract. If it asks for a distance, a negative number is invalid. If it asks for a probability, the result must lie between zero and one.

Write down the required object, domain, precision, and units. For example:

object: roots of a quadratic equation
domain: real numbers
precision: exact radicals preferred
constraints: substitute each candidate into the original equation

The contract is a simple but powerful guardrail. It prevents a technically correct intermediate calculation from being mistaken for the requested conclusion.

3. Generate a Candidate Solution, Not a Verdict

The first solution should be labeled a candidate. This wording changes behavior. A candidate invites testing; a verdict invites confirmation bias.

Ask the solver to expose intermediate states. In algebra, preserve both sides of an equation after each transformation. In calculus, name the rule used for every derivative or integral. In geometry, connect each conclusion to a theorem and its hypotheses. In probability, define the sample space before counting outcomes.

A compact trace might look like this:

input -> normalized expression -> method selection
      -> intermediate transformations -> candidate result

Avoid combining unrelated transformations in one line. Small steps create more checkpoints, but they also make failures local and understandable.

4. Validate Every Transformation

Not all algebraic transformations are reversible. Squaring both sides can introduce extraneous solutions. Dividing by an expression can discard the case where that expression equals zero. Taking a logarithm requires a positive argument. Multiplying an inequality by an unknown-sign expression can reverse the inequality.

For each step, ask two questions:

What rule permits this transformation?
Under what conditions is the rule valid?

Record any newly introduced condition next to the step. If you divide by x - 3, branch the reasoning and inspect x = 3 separately. If you apply a square root, state whether the principal root is intended. If a substitution changes the domain, map the final candidates back to the original variable.

This process resembles runtime assertions in software. The assertion is not the calculation itself; it is a check that the calculation is being applied within its legal range.

5. Verify With the Original Problem

A transformed expression is not the final authority. The original problem is. Substitute every candidate into the original equation, not merely the last simplified form. Check all original denominators, radicals, logarithms, interval restrictions, and geometric constraints.

For numerical answers, evaluate both sides independently. If the result is approximate, compare using a tolerance appropriate to the calculation rather than exact floating-point equality. A small script can help:

from math import isclose

left = evaluate_left(candidate)
right = evaluate_right(candidate)
assert isclose(left, right, rel_tol=1e-9, abs_tol=1e-12)

The tolerance should be justified. A measurement reported to two decimal places should not be presented with twelve digits of artificial precision.

6. Use an Independent Representation

The strongest verification method changes the representation. Repeating the same symbolic steps often repeats the same mistake.

For an algebra problem, compare symbolic substitution with a numerical sample or a graph. For a derivative, compare the symbolic derivative with finite differences at several safe points. For a definite integral, compare the antiderivative result with numerical quadrature. For a probability calculation, compare a formula with a small enumeration or simulation. For a geometry result, reconstruct coordinates and calculate the same quantity analytically.

Independence matters more than complexity. A rough graph or ten carefully selected samples can reveal a sign error that remains invisible in a polished derivation.

7. Check Boundary and Special Cases

Many incorrect solutions work for typical values and fail at boundaries. Build a small test suite around the answer:

zero and one, when they are in the domain;
endpoints of intervals;
values just below and above a discontinuity;
symmetric inputs such as x and -x;
very small and very large magnitudes;
degenerate geometric configurations;
empty or single-element sample spaces.

For a function, test whether the claimed behavior matches limits and asymptotes. For an optimization problem, compare interior critical points with all allowed endpoints. For a recurrence, verify the base case before trusting an inductive pattern.

These checks are inexpensive and often more informative than another full derivation.

8. Track Units and Scale

Units form a lightweight type system. Adding meters to seconds is invalid, just as adding a string to an integer is invalid in a strongly typed program. Every physical quantity should carry its unit through the computation.

Before accepting a result, confirm dimensional consistency and order of magnitude. A classroom length is unlikely to be thousands of kilometers. A probability cannot be 140 percent unless the quantity was mislabeled. An area result should have squared units, and a volume should have cubed units.

Scale checks do not prove correctness, but they reject many impossible answers quickly.

9. Separate Confidence From Evidence

A fluent explanation is not evidence. Confidence should be tied to passed checks. A useful report distinguishes three layers:

candidate: the proposed answer;
evidence: substitutions, tests, alternate methods, and constraints;
remaining uncertainty: ambiguous input, rounding, or an untested assumption.

This structure is especially important when the original problem came from a photograph or when a diagram is not drawn to scale. State what was observed and what was inferred.

10. Produce a Verification Report

The final output should be more than a number. It should summarize the audit trail:

Input transcription: checked
Domain restrictions: checked
Candidate generation: complete
Original-equation substitution: passed
Independent method: passed
Boundary cases: passed
Units and precision: checked
Final answer: accepted

If one check fails, do not hide it. Return to the earliest stage that could explain the failure, revise the candidate, and run the checks again. This is the mathematical equivalent of fixing the source rather than patching the test output.

A Practical Implementation Pattern

A small verification application can model the workflow as immutable stages. Each stage receives the previous state and returns a new state plus evidence. Failed checks stop promotion but preserve diagnostic data.

from dataclasses import dataclass, field

@dataclass
class SolutionState:
    original: str
    transcription: str = ""
    constraints: list[str] = field(default_factory=list)
    steps: list[str] = field(default_factory=list)
    candidates: list[str] = field(default_factory=list)
    checks: dict[str, bool] = field(default_factory=dict)


def ready_for_acceptance(state: SolutionState) -> bool:
    required = {
        "transcription",
        "domain",
        "substitution",
        "independent_method",
        "boundary_cases",
    }
    return required.issubset(state.checks) and all(
        state.checks[name] for name in required
    )

The exact data model will vary, but the central invariant is stable: a candidate cannot become an accepted answer unless every required verification gate has explicit evidence.

Conclusion

AI-assisted mathematics becomes more reliable when generation and verification are treated as separate responsibilities. Preserve the prompt, define the answer contract, generate a candidate, validate every transformation, test candidates in the original problem, and compare with an independent representation. Then examine boundary cases, units, and unresolved assumptions.

This pipeline does not remove judgment. It makes judgment visible and repeatable. That is the real advantage of a verification-first workflow: not merely getting more answers, but knowing why a particular answer deserves to be trusted.

How I Built a Physics AI Solver to Visualize Complex Equations and Help Students

Neuhaus Barsuhn — Mon, 04 May 2026 06:08:31 +0000

Physics has always been one of those subjects that feels like a maze of invisible forces and abstract variables. To make learning more intuitive, I recently launched Physics AI Slover, a specialized platform designed to provide step-by-step solutions and visual derivations for students struggling with mechanics, electromagnetism, and thermodynamics.
The motivation behind this project was simple: most AI models give you a text-based answer, but physics is inherently visual. You can't truly understand a pulley system or a circuit loop without seeing the vectors and the flow. By integrating advanced reasoning models with a focus on educational clarity, I wanted to build a tool that doesn't just "give the answer," but actually teaches the underlying logic.
Why "Solver Mode" and "Tutor Mode" Matter
One of the core challenges in EdTech is balancing convenience with actual learning. In building this tool, I implemented two distinct paths for users.

Solver Mode is for that 2 AM panic when you just need to check if your final numerical result is correct. It’s fast, precise, and gets straight to the point.
Tutor Mode, however, is where the real value lies. It uses a Socratic approach to ask leading questions, helping users build a mental model of the problem instead of just copying a derivation.

The Technical Hurdle: Visualizing the Invisible
From a development perspective, the hardest part wasn't the LLM integration—it was the visualization engine. When a student uploads a photo of a messy, hand-drawn free-body diagram, the system needs to interpret those vectors correctly. We spent a lot of time fine-tuning the vision processing to ensure that gravity components, tension arrows, and friction forces aren't just recognized as "lines," but as physical entities with direction and magnitude.
Seeing a position-vs-time graph generated instantly from a word problem helps bridge the gap between abstract math and physical reality. It turns "formulas to memorize" into "behaviors to observe."
Breaking the "Black Box" of AI
We’ve all seen AI "hallucinate" math results. To combat this, the engine behind the site is forced to show every single step of the algebraic rearrangement. If a unit conversion happens, it’s documented. If a constant is substituted, it’s highlighted. This transparency is crucial for students who need to follow the "how" and "why" to prepare for their exams.
Whether you are tackling AP Physics in high school or diving into Maxwell’s equations in college, having a 24/7 study partner that can read your diagrams and explain the derivation is a game-changer. I'm looking forward to hearing feedback from this community on how we can further improve the accuracy of the vector analysis and the overall user experience!

How I Built a Physics AI Solver to Visualize Complex Equations and Help Students

Neuhaus Barsuhn — Mon, 04 May 2026 06:08:31 +0000