Raghav Agrawal @[email protected]
@impactology.bsky.social
2.1K followers 3.3K following 5.7K posts
Former Diamond Dealer | Independently explored research in design, education, and cognitive science; now bringing those ideas to life via UX https://twitter.com/impactology
Posts Media Videos Starter Packs
impactology.bsky.social
What a UI design course or book should be like

Purely skill-focused, execution-oriented handbook for building useful, usable, and emotionally intelligent interfaces from sketch to production.
The Full-Stack Design Engineer’s Field Manual
A skill-based, execution-oriented handbook for building useful, usable, and emotionally intelligent interfaces — from sketch to production.
I · Model the System
• Build clarity before pixels.
• Map the conceptual model — what objects exist, what they can do, and how they relate.
• Compare system, designer, and user models to catch mismatched assumptions.
• Define interface language — verbs, nouns, and visible states — that reflect the model.
• Draw one diagram that links data, interaction, and feedback.
• Prototype system logic in a quick interactive scaffold (spreadsheet, flow builder, or sandbox).
• Output → a single-page system model that can guide every design choice.
II · Structure the Interaction
• Shape flows and states that match system logic.
• Use Five Design Sheets to explore multiple structural solutions, not just visual variants.
• Define interaction units (tasks) and their entry, transformation, and exit states.
• Diagram the behavior logic: triggers, rules, feedback, and loops.
• Combine related flows into a state map that exposes dependencies and reuse.
• Output → a tested interaction backbone: every possible state accounted for.
IV · Express the Logic Visually
• Turn invisible behavior into visible structure.
• Build a visual grammar (type, color, space, iconography) tied to functional roles.
• Represent state change through clear visual transitions, not arbitrary motion.
• Balance procedural, participatory, spatial, and encyclopedic affordances (Murray).
• Design for hierarchy of attention: one dominant action per view.
• Output → a motion-ready interface where visuals communicate system reasoning.
V · Encode the Interface
• Translate design intelligence into reusable components.
• Name components after conceptual roles, not visual appearance.
• Bind each component to state rules defined in the model.
• Tokenize spacing, color, and timing so they can be coded exactly once.
• Pair with developers to validate constraints, breakpoints, and animation curves.
• Output → a working component library whose naming mirrors system logic.
VI · Test the Experience Mechanically
• Evaluate performance, coherence, and cognitive load.
• Run latency and feedback audits on real devices.
• Time every key interaction; identify drags beyond 300 ms.
• Check consistency between concept, copy, and behavior.
• Use heuristic testing focused on precision: clarity, latency, reversibility, and tone.
• Output → an audit log that treats UX quality as measurable mechanical feedback.
VII · Communicate for Implementation
• Make reasoning visible to collaborators.
• For every major decision, write a 3-line rationale: problem → principle → choice.
• Present interaction diagrams and timing tables in developer-ready form.
• Conduct critique sessions that target coherence and responsiveness, not aesthetics.
• Maintain a decision ledger that captures the evolution of the model.
• Output → shared understanding that keeps logic intact through production.
VIII · Maintain Conceptual Integrity
• Keep growth from breaking the model.
• Schedule monthly model audits — does the interface still match core concepts?
• Trace every new feature to a node on the original diagram.
• Refactor inconsistencies before they propagate.
• Archive motion and logic tests as regression references.
• Output → a continuously evolving but internally consistent interface system.
IX · Ship and Reflect
• Close the loop like an engineer.
• Compare the shipped build against conceptual and interaction specs.
• Record deltas: motion offsets, color drift, timing variance.
• Fix or document trade-offs and feed learnings back into tokens or models.
• Write a one-page post-flight report per release — what worked, what broke, what’s next.
impactology.bsky.social
This seems like a successor to buxton's sketching user experiences
Five Design Sheets, framework for prototyping information visualization interfaces via sketching by Jonathan C. Roberts, Christopher J. Headleand, Panagiotis D. Ritsos
www.springerprofessional.de/en/five-desi...
fds-design.github.io
Five Design-Sheets: Creative Design and Sketching for Computing and Visualisation
This book describes a structured sketching methodology to help you create alternative design ideas and sketch them on paper. The Five Design-Sheet method acts as a check-list of tasks, to help you think through the problem, create new ideas and to reflect upon the suitability of each idea. To complement the FdS method, we present practical sketching techniques, discuss problem solving, consider professional and ethical issues of designing interfaces, and work through many examples. Five Design-Sheets: Creative Design and Sketching for Computing and Visualization is useful for designers of computer interfaces, or researchers needing to explore alternative solutions in any field. It is written for anyone who is studying on a computing course and needs to design a computing-interface or create a well-structured design chapter for their dissertation, for example. We do acknowledge that throughout this book we focus on the creation of interactive software tools, and use the case study of building data-visualization tools. We have however, tried to keep the techniques general enough such that it is beneficial for a wide range of people, with different challenges and different situations, and for different applications.
www.springerprofessional.de
Reposted by Raghav Agrawal @[email protected]
tomasp.net
I'm at #uist2025 presenting our new work with @jonathoda.bsky.social!

𝗗𝗲𝗻𝗶𝗰𝗲𝗸 is a computational substrate for end-user programming that makes it easy to implement programming experiences like programming by demonstration, collaborative editing and more!

tomasp.net/academic/pap...
Reposted by Raghav Agrawal @[email protected]
tomasp.net
I'm teaching 𝗪𝗿𝗶𝘁𝗲 𝘆𝗼𝘂𝗿 𝗼𝘄𝗻 𝘁𝗶𝗻𝘆 𝗽𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴 𝘀𝘆𝘀𝘁𝗲𝗺(𝘀)! again. I'll be posting the videos & tasks on YouTube too.

In the first lecture, I explain what's a tiny system, why write one and show plenty of demos!

🎞️ Playlist: www.youtube.com/playlist?lis...
👉 More info: d3s.mff.cuni.cz/teaching/npr...
Write your own tiny programming system(s)! - YouTube
The goal of this course is to teach how fundamental programming language techniques, algorithms and systems work by writing their miniature versions. The cou...
www.youtube.com
Reposted by Raghav Agrawal @[email protected]
tomasp.net
Can software express critical reflections on its own nature in the same way post-modern architecture does?

I don't have the answers, but I wrote a long text with some early thoughts: tomasp.net/architecture/
impactology.bsky.social
When concepts overflow human bandwidth, design learning as a looping system, externalized, multimodal, emotionally anchored, and temporally layered so understanding accumulates through recurrence, not recall.
impactology.bsky.social
This builds narrative continuity, memory of contact becomes the learning structure itself.

Finally, make the process itself visible.

Say:

“This topic can’t be grasped all at once. Each time we circle back, we’ll see more structure"
impactology.bsky.social
Reflective prompts: “What seems obvious now that was confusing last week?”

Breadcrumb system: Auto-link previous explorations (like browser history for understanding).
impactology.bsky.social
To make sustained contact possible, the environment must remember and reflect progress:

Dashboards of confusion: Learners log “what I still don’t get.” The next session starts there.

Versioned artifacts: Old sketches or simulations remain visible, so growth is tangible.
impactology.bsky.social
Systemic transfer: Apply to a new context.
→ “How does this explain algorithmic compression?”

Let the learner’s mind chew between layers.
impactology.bsky.social
Mechanistic lens: Introduce 1–2 governing variables. → “Notice that as microstates increase, predictability drops.”

Quantitative lens: Formalize with notation or model. → “Let’s write S = k log W.”
impactology.bsky.social
Layer Through Time (Progressive Resolution)

Encounter: Raw, sensory example that evokes the phenomenon. → “Watch smoke spread in slow motion.”

Crude story: A poetic handle for orientation.
→ “Entropy measures how many ways things can be arranged.”
impactology.bsky.social
Formal (symbolic / mathematical): “Entropy = –∑p log p.”

Cycle among them constantly. Each switch acts as a translation exercise that deepens encoding
impactology.bsky.social
Every hard concept should exist in at least three representational forms:

Intuitive (felt / metaphorical): “Entropy is surprise.”

Graphical (visual / geometric): “Entropy is area under this curve.”
impactology.bsky.social
Build lightweight interactive models that can be revisited in 2–5 minutes (e.g., small interactive demos, metaphors, sketches)

Each return should slightly shift context, same concept but new variables so the learner feels deepening, not repetition.
impactology.bsky.social
Instead of asking How do I explain this clearly once?, ask: How can I design multiple small interactive resources that make coming back easy and meaningful?
impactology.bsky.social
When a concept exceeds working memory, language, or linear instruction, you have to distribute cognition across time, space, tools, and emotion so that the learner doesn’t have to hold it all in their head at once.
impactology.bsky.social
Any concept rich enough to matter will overflow the learner’s immediate bandwidth. So role of teacher, designer, or explainer is not to tame complexity, but to scaffold sustained contact with it

To build an environment where people can return to the concept repeatedly, each time with sharper eyes
impactology.bsky.social
Entropy seems teachable : disorder in a system but zoom in and you hit Boltzmann statistics, phase space, probability density, and information theory.
impactology.bsky.social
How to handle concepts whose detail exceeds our working memory, language, or linear instruction?

The Core Problem: Granularity Outpaces Compression

Every domain hides layers of detail that can’t be collapsed without distortion. At a certain level, the idea refuses to shrink.
impactology.bsky.social
This means the art of teaching is the art of constructing relevant detailed examples on the fly

Question is how does one get good at example construction
impactology.bsky.social
The answer is examples. Good concrete and vivid examples that are relatable, that embody how the concept solves a problem in a rich real world context with multiple constraints, contradictions, variables.

That is how you compress a concept without losing detail.
impactology.bsky.social
The art of iteratively forming understanding of a concept in a newbie's mind as you expose them to a series of concepts, how to pack explanations that engage and form understanding of even the hardest concepts in flat 2 hours or less
impactology.bsky.social
Context, so I was basically thinking how do you pack understanding of something dense and complex in 2 hours flat

Like how do you unpack something that is deeply technical or complicated or abstract in a way without missing any detail in daily 2 hour sessions