Research Brief
A literature brief from Ubicomp, HCI, and adjacent fields
HCI and ubiquitous computing have long treated the sealed “app” and the shared SaaS platform as a cost compromise rather than an end state. When building and maintaining software is expensive, scale and shared infrastructure win; when generation and maintenance become cheap, local fit wins.
The classic literature — Weiser’s ubiquitous computing, calm technology, context-aware systems, tailorability, appropriation, and malleable substrates — argues that software should either fade into practice or be reshaped by the people who use it. Post-2020 work on generative user interfaces shows that large language models can synthesize task-specific interfaces cheaply enough that disposable or hyper-personal tools are now technically plausible. Meanwhile, enterprise information-systems research on low-code, citizen development, and shadow IT already documents the pull toward personalization against central platforms, together with its governance and lock-in costs.
What the literature does not settle is whether generative personal software displaces enterprise SaaS at scale, or proliferates alongside it under new forms of governance. The link from reverse engineering to SaaS market structure is only lightly covered in HCI — chiefly through systems that reverse-engineer user interfaces — and not as a mature body of security-economics research.
Core texts that define the long-standing HCI bet: software should fit practice.
Recent systems showing LLMs can synthesize task-specific interfaces on demand.
Supporting work on how people reshape software, and how organizations govern it.
HCI covers reverse engineering of interfaces, not its market or IP consequences.
| Dimension | Platforms / scale | Hyper-personal / generative |
|---|---|---|
| Cost | Building and maintaining software is expensive, so cost is shared via SaaS and platforms; low-code still ships as platforms with lock-in (Bock & Frank 2021). | Generation cost is collapsing, so personal and disposable apps become affordable (Cao et al. 2025; Cheng et al. 2024; Nandy et al. 2024). |
| Users | Most users avoid customization; it spreads via few “translators” (Mackay 1990). | Appropriation and EUD show demand for fit; shadow IT and citizen development prove organizational demand when platforms do not fit (Dourish 2003; Klotz et al. 2019). |
| UX | Fixed apps and shared SaaS give predictable UX, auditability, and support. | Malleable substrates and generative task models replace app-switching with one evolving space (Klokmose et al. 2015; Fox et al. 2020; Cao et al. 2025) — with a risk of churn against calm computing. |
| Enterprise | Governance, security, and compliance push central platforms; citizen tools are managed, not abolished (Biedova et al. 2024). | Shadow IT and business-managed IT already decentralize; generative EUD may amplify that unless platforms become malleable enough to absorb personalization. |
| RE | SaaS stickiness partly from opacity and integration; reverse-engineering tools show UIs can be read without vendor cooperation — an under-studied competitive pressure. | The same capability enables personal overlays and mashups on top of SaaS (augmentation more than replacement). |
From the vision of disappearing computing, through the culture of tailoring and a working malleable substrate, to generative malleable UI, and finally to the enterprise reality of shadow IT.
The pack converges on a few durable points. Weiser’s ubiquitous computing and Weiser & Brown’s calm technology treat the sealed app as a failure of imagination: computation should inhabit the periphery and only take the center when needed. The “app” is not destiny; it is what you ship when attention and maintenance are scarce. End-user development and appropriation (MacLean et al. 1990; Lieberman et al. 2006; Dourish 2003) show that people bend tools toward local practice when the cost of bending is low enough — and that bending is social, not solitary. Malleable substrates (Klokmose et al. 2015; Borowski et al. 2023; Fox et al. 2020) push further: software as shareable, runtime-modifiable media rather than purchased screens. Years of Webstrates work also show the pragmatic costs of living that principle.
Post-2020 generative and just-in-time UI work (Cao et al. 2025; Vaithilingam et al. 2024; Cheng et al. 2024; Nandy et al. 2024) collapses the cost of producing task-specific interfaces. Disposable widgets, agent-generated just-in-time surfaces, and evolving task-driven data models are peer-reviewed systems, not slideware. That cost curve is what makes the old HCI bet newly material inside enterprises. At the same time, research on shadow IT and citizen development (Klotz et al. 2019; Hoogsteen & Borgman 2022; Biedova et al. 2024; Bock & Frank 2021) already documents the organizational pull toward personalization — and the governance debt that follows when central platforms cannot absorb local fit. Low-code did not dissolve the tension; it relocated lock-in.
Two cautions travel with the optimism. Mackay (1990) remains the realism check: most people do not deeply customize; time spent customizing is time not working, and practice spreads through a few translators and shared configs. Hyper-personal software will not mean everyone authors; it will mean a few generate, many reuse, and organizations must decide what is allowed to persist. And Prefab / Screen Parsing (Dixon & Fogarty 2010; Wu et al. 2021) show that UIs are readable from the outside. Personal overlays on platforms are therefore technically tractable — and competitive moats that are only skin-deep are fragile.
Read together, the literature does not license a simple story that “apps die.” It licenses a sharper one: when generation is cheap, the locus of competition moves from shipping screens to governing fit on top of shared platforms — and calm, appropriation, and shadow-IT research all become practical design constraints rather than academic color.
Short business ideas Material could explore. Each is grounded in the pack; none is a validated offer yet.
A productized diagnostic that maps where platforms fail local practice — the seams between systems, people, and process — before any agent or app is built.
Shadow IT literature (Klotz et al. 2019) treats workarounds as signals of misfit, not mere compliance failures. Appropriation research (Dourish 2003; Mackay 1990) shows where and how people already bend tools.
A fixed-scope engagement and deliverable: seam map, ranked automation candidates, and a governance posture — sold before build.
A studio that generates task UIs and lightweight apps with policy, identity, and logging baked in from the first prompt — not bolted on after a demo.
Cao et al. (2025) and Webstrates (Klokmose et al. 2015) show malleable generative surfaces; Biedova et al. (2024) show what happens when citizen tools lack management strategies.
A retained studio capacity plus a policy pack: identity hooks, retention rules, and promotion paths from personal to shared.
Personal agents and UIs that sit on Salesforce, ServiceNow, and peers without rip-and-replace — reading and writing through the platform rather than competing with it.
Prefab and Screen Parsing (Dixon & Fogarty 2010; Wu et al. 2021) establish that UIs and structures can be understood from outside vendor control; Wang et al. (2023) show LLMs operating existing mobile UIs.
Overlay accelerators per major system of record, sold as fit layers, not replacement suites.
Disposable interfaces for one-off enterprise workflows — incident bridges, quarter-close checklists, migration cutovers — with explicit retention and discard policy.
BISCUIT and DynaVis (Cheng et al. 2024; Vaithilingam et al. 2024) demonstrate ephemeral generated widgets users prefer for control; the open question in the brief is when to keep, version, or discard.
A widget runtime with TTL, audit trail, and a catalog of reusable patterns — billed per campaign or retainer.
Instrumentation and fieldwork that measure how teams actually bend tools, then feed those bends into the next automation and overlay backlog.
Mackay (1990) and Dourish (2003) make appropriation observable and social; Klotz et al. (2019) treat shadow IT as both innovation signal and risk.
A recurring insight product: quarterly appropriation report tied to seam backlog and value-realization metrics.
Agent and generative-UI design that fights interface churn — periphery-first notifications, stable shells, generated interiors only where attention is warranted.
Weiser & Brown (1996) warn that technology demanding constant attention fails calm computing; the brief’s open questions flag regenerated UIs as an attention risk.
UX and architecture standards for agentic delivery, plus design reviews sold into build engagements.
Playbooks and operating models for organizations whose employees will generate tools whether IT likes it or not — sold alongside build, not instead of it.
Hoogsteen & Borgman (2022) and Biedova et al. (2024) document adoption conditions and management strategies; Bock & Frank (2021) warn of low-code lock-in.
A governance retainer: policy templates, promotion gates, risk reviews, and training for translators (Mackay’s sense).
Reusable, business-ready packages that compose two or three systems of record with a generative UI and a governed data generator — identity, lineage, retention, and promotion gates included. Example packages (pair → outcome): Salesforce + ServiceNow → Customer 360 / field service; Salesforce + NetSuite (ERP) → quote-to-cash; Workday + ServiceNow → hire-to-retire; Marketing Cloud or HubSpot + Salesforce → campaign-to-lead; Salesforce + ERP → case-to-cash; marketing stack + CRM → marketing opportunity surfaces.
Prefab / Wang (operate and overlay existing UIs) + Cao malleable generative UI + Biedova / Klotz (governance) + Bock & Frank (avoid becoming another lock-in platform by packaging use cases, not a mega-suite).
Verticalized package IP — playbook + connectors + policy pack + generative UI templates — licensed or implemented per pair of systems. This is where Material’s IP concentrates: the cross-system use-case graph and governance, not the underlying SaaS.
Beyond overlays on a single SaaS surface: Material can create IP by packaging business-ready use cases that sit atop two or three systems of record — generative UI plus a governed data generator — rather than competing with any one vendor’s screens.
On LinkedIn and in talks, Material should sound like translators of HCI futures into enterprise change — not model shoppers. The slate already points the way: seams before agents, identity before autonomy, one governed agent as a wedge, and a value-realization chain that survives the pilot. The literature brief supplies vocabulary without hype: calm computing as a design constraint, appropriation as a discovery method, shadow IT as a signal, SaaS as substrate rather than enemy.
Say what the pack supports. Label what is inference. Put provocations in a clearly marked box. That separation is itself a credibility move against vendors who blur demo and product.
Discovery questions that belong in the room: Where do people already work around the platform? What identity and audit requirements travel with any new automation? Which single governed agent would prove the wedge without a fifty-agent slide? How will value be measured after the pilot — not just usage?
One-slide story: Platform → Substrate → Governed generation → Value realization. Contrast that with “we’ll build you fifty agents.” The point is not more software; it is fit on top of what already holds the records, with policy and measurement attached. SaaS stays. What changes is what enterprises buy next: fewer sealed features, more governed fit.
Near-term: Seam Diagnostic as a fixed-scope entry; one governed agent on a system of record as the wedge delivery; citizen-dev / generation governance playbooks as a retainer alongside build. Pick one SoR pair (for example Salesforce + ServiceNow) and ship a single packaged generative use case — Customer 360 or marketing opportunities — as proof IP: connectors, policy pack, and generative UI templates together. Later: Governed Personal Apps studio; SaaS-as-substrate overlay accelerators; ephemeral ops widget runtime; appropriation analytics as a recurring insight product; and a catalog of SoR pairs × outcomes — Customer 360, field service, quote-to-cash, hire-to-retire, campaign-to-lead, and kin — as licensed Cross-SoR Generative Packages. Sequence matters — diagnostics and one governed wedge fund trust; studios, overlays, and pair packages scale once identity and audit are proven.
Demos that earn the narrative: an ephemeral governed widget with TTL and audit visible; an overlay on a real SaaS surface that does not pretend to replace it; a before/after seam map that connects appropriation evidence to an automation backlog; and one cross-SoR package storyboard (two systems → governed generator → named outcome) that makes the IP claim concrete. Not chat toys over a warehouse. Not fifty-agent architecture theater. Proof that generation can travel with identity, and that Material finds seams before it generates.
Being the firm that names the risks is the credibility move. Calm-computing failure modes: regenerated UIs that demand more attention than they save (Weiser & Brown 1996; open questions in this brief). Lock-in via low-code platforms (Bock & Frank 2021). Maintenance of generated artifacts — who versions, who pays when the task model drifts. Reverse-engineering and IP gray zones around UI overlays (the RE strand is narrow; do not overclaim). Shadow IT 2.0 when generation is cheap and governance is late (Klotz; Biedova). Name these in the pitch. Buyers hear the difference.