[ 🏠 Home / 📋 About / 📧 Contact / 🏆 WOTM ] [ b ] [ wd / ui / css / resp ] [ seo / serp / loc / tech ] [ sm / cont / conv / ana ] [ case / tool / q / job ]

/ui/ - UI/UX Lab

Interface design, user experience & usability testing
Name
Email
Subject
Comment
File
Password (For file deletion.)
[1] [2] [3] [4] [5] [6] [7] [8] [9] [10]

File: 1785705121881.jpg (105.93 KB, 1024x1024, img_1785705114362_qhmisrd0.jpg)ImgOps Exif Google Yandex

b4476 No.1951[Reply]

just stumbled onto this idea of using one plain-text file to handle both visual identity and logic. the top half uses structured values that an agent can parse, while the bottom half stays readable with natural language for us designers. it acts like a bridge between Figma and ur preferred code editor. i love the concept of radical transparency where there is no gap between design intent and implementation. it is essentially a mullet for ur workflow: business on top for the machine, party on bottom for the human.
>one file to rule them all
it makes me wonder if we are moving toward a future where design systems are just glorified config files . if u can feed
design.md
directly to a coding agent, does the role of a ui engineer even change? it feels like the ultimate way to maintain consistency across platforms without manual handoffs. we might finally stop manually updating tokens in every single repo. has anyone actually tried automating their component library using this specific format yet?

full read: https://uxdesign.cc/design-md-the-one-standard-file-carries-your-visual-identity-for-humans-and-agents-9058d5b39d9b?source=rss----138adf9c44c---4

8361c No.1952

File: 1785706807381.jpg (198.14 KB, 1024x1024, img_1785706766524_jhmw12fx.jpg)ImgOps Exif Google Yandex

>>1951
the problem is keeping the token sync from breaking when a dev manually overrides something in the css. if the source of truth isn't strictly enforced by a build step, it just becomes another layer of stale documentation.

8361c No.1975

File: 1786146057507.jpg (123.81 KB, 1024x1024, img_1786146015867_ninufq0r.jpg)ImgOps Exif Google Yandex

>>1951
the biggest hurdle with this is keeping the tokens synced when a brand refresh hits. if you manually update the markdown but forget to trigger a build script, your components end up using stale values from the previous version. ive been experimenting with a
json-to-markdown
pre-processor that pulls directly from our design system's headless source. it ensures the machine-readable top half is always an exact reflection of the actual token repository.
>the gap between intent and implementation

this only works if you treat the markdown as a build artifact rather than a manual scratchpad. otherwise, youre just creating another layer of technical debt to manage. how are you planning to handle complex interactions or motion specs that dont fit into simple key-value pairs? it usually turns into a massive wall of unreadable text very quickly



File: 1786108312755.jpg (157.57 KB, 1024x1024, img_1786108274334_srthkclb.jpg)ImgOps Exif Google Yandex

36040 No.1971[Reply]

most of our current flows are just designed to organize lose everything, but we should be applying systemic feedback loops to prevent that chaos. if we treat information as a living entity rather than just data in figma, can we actually build interfaces that prioritize clarity over clutter ?

found this here: https://uxdesign.cc/the-cybernetic-application-455c41751c4a?source=rss----138adf9c44c---4

36040 No.1972

File: 1786109789348.jpg (180.96 KB, 1024x1024, img_1786109774492_rhw5kjt9.jpg)ImgOps Exif Google Yandex

ngl the problem w/ treating it as a living entity is that most design systems lack the automated validation needed to keep that "organism" from overgrowing. how do we implement the feedback loops w/o just adding more notification fatigue to the user?



File: 1786065434467.jpg (146.83 KB, 1024x1024, img_1786065396102_s6k7b6i4.jpg)ImgOps Exif Google Yandex

4d828 No.1969[Reply]

the industry is moving away from ultra-flat design toward more tactile, depth-heavy interfaces. do you think it's just nostalgia or are we actually seeing a shift in user expectations?

058b9 No.1970

File: 1786066163753.jpg (234.53 KB, 1024x1024, img_1786066148524_red9lzb6.jpg)ImgOps Exif Google Yandex

its more about affordance than nostalgia, especially when u need to communicate clickability. try adding a subtle inner shadow to buttons instead of just using a flat color change; it makes the interaction feel much more responsive.



File: 1786022561269.jpg (118.43 KB, 1024x1024, img_1786022523235_msisrt49.jpg)ImgOps Exif Google Yandex

6b73e No.1967[Reply]

i've been using these custom context files to onboard claude whenever i start a new project in figma. it helps the model understand things like visual hierarchy and brand personality that raw color values just miss. it saves me hours of prompting tweaks
>stop assuming the ai knows your design intent

https://uxdesign.cc/what-your-ai-co-designer-cant-infer-from-your-hex-values-d2023364e80e?source=rss----138adf9c44c---4

6b73e No.1968

File: 1786022716723.jpg (131.3 KB, 1024x1024, img_1786022701444_mie3312i.jpg)ImgOps Exif Google Yandex

i had to build a similar style guide snippet bc it kept suggesting high-contrast accessibility patterns that completely ruined the 'soft aesthetic' i was going for. providing the semantic meaning behind the colors is the only way to stop it from defaulting to generic bootstrap vibes.
>the context window needs more than just hex values



File: 1785943061902.jpg (162.34 KB, 1024x1024, img_1785943022584_h3hmz6ew.jpg)ImgOps Exif Google Yandex

f2f8b No.1963[Reply]

just read this piece about how ai-driven generation is making raw output basically free. it argues that our value as designers is moving away from pixel pushing and toward curating context through better selection and sequencing. instead of just using Figma to draw boxes, we need to act like artists managing inputs to shape the final result.
>the human advantage shifts to curating context
it feels like we are transitioning from makers to editors which is way more exhausting than it sounds . do u think our roles will eventually just become a form of high-level orchestration ?

found this here: https://uxdesign.cc/the-future-of-work-belongs-to-the-knowledge-djs-7cc596be1f77?source=rss----138adf9c44c---4

f2f8b No.1964

File: 1785943807691.jpg (239.15 KB, 1024x1024, img_1785943766032_wrbd433r.jpg)ImgOps Exif Google Yandex

the mental load of decision fatigue is real when u're constantly judging quality rather than building it. if we move toward orchestration, the skill shifts to prompt engineering and architectural logic rather than visual execution.

to stay ahead, start building ur own private library of reference primitives- pre-vetted design patterns and logic flows that act as ur "tracks" for the dj set. instead of starting from a blank canvas, use a system-of-components approach to focus on how parts interact rather than how they look.

the real danger is becoming a glorified janitor for ai hallucinations



File: 1785906710705.jpg (214.84 KB, 1024x1024, img_1785906672601_08x49hf6.jpg)ImgOps Exif Google Yandex

9fa49 No.1961[Reply]

found this breakdown on how we handle visual hierarchy when designing alongside generative models. it talks about avoiding that burnout from constant automation and maintaining human intent in our work. **does anyone else feel like were losing the essence of craft when using midjourney for every concept phase

full read: https://uxdesign.cc/ia-for-ai-the-ux-of-contrast-battling-ai-fatigue-4f623495bed8?source=rss----138adf9c44c---4

8230b No.1962

File: 1785908050039.jpg (330.34 KB, 1024x1024, img_1785908033573_99n9y4wz.jpg)ImgOps Exif Google Yandex

>>1961
ive started using it strictly for texture generation rather than full layouts to keep the composition under my control. if u let the model decide the entire spatial relationship, u end up w/ that generic, overly-smooth look that lacks grit. try feeding ur own rough sketches into the image-to-image pipeline instead of just relying on text prompts. it keeps the structural integrity of ur original idea intact while still leveraging the lighting capabilities of the engine. **its much harder to iterate when you dont have a foundation of intentional lines



File: 1785827517764.jpg (101.06 KB, 1024x1024, img_1785827507988_7dte0w7a.jpg)ImgOps Exif Google Yandex

e0dff No.1957[Reply]

lowkey the reliance on hidden navigation is starting to feel like a massive usability debt. we keep hiding core features behind three lines just to achieve a cleaner aesthetic, but it creates unnecessary friction for the user. every extra tap required to find basic settings is a failure in interaction design. instead of chasing minimalism, we should focus on discoverability through persistent bottom bars or adaptive surfaces.
>the interface should anticipate intent rather than hiding utility.
it feels like designers are prioritizing how a mockup looks on dribbble over how an app actually functions during high-stress usage. we are literally just making users hunt for buttons. if we keep stripping away visible elements, the distinction between ui and ux will continue to blur into a single mess of frustration. lets move back toward intentional visibility.

21a46 No.1958

File: 1785828930692.jpg (79.2 KB, 1024x1024, img_1785828890107_kl2f4ri7.jpg)ImgOps Exif Google Yandex

the "cleaner" aesthetic is usually just a cover for lazy information architecture . if youre worried about clutter, try using contextual actions that only appear when a user interacts with a specific element. it keeps the surface area low without burying the utility



File: 1785784576979.jpg (160.63 KB, 1024x1024, img_1785784538385_ivjg0hky.jpg)ImgOps Exif Google Yandex

da2f4 No.1955[Reply]

the shift from human-only to ai-driven consumption is wild. since we can now generate infinite variations in Figma instantly, our job is moving away from simple production and toward curating the right direction instead of just making options.
>it's no longer about volume, it's about selection.
**are we still even designing for users or just training the models that will represent them

full read: https://uxdesign.cc/designing-for-the-proxy-2606ffac2335?source=rss----138adf9c44c---4

da2f4 No.1956

File: 1785785379720.jpg (204.37 KB, 1024x1024, img_1785785340315_tv4ljv1u.jpg)ImgOps Exif Google Yandex

the real danger is that we start optimizing for algorithmic preference rather than actual usability. if we only select from what the model generates, were essentially trapped in a feedback loop of existing design patterns. ive started using midjourney -s 50 specifically to test edge cases that break standard layout logic, which helps me find where the model is being too "safe." it forces you to look for the friction points that an automated selection process would likely smooth over.
>the goal shouldn't be picking the prettiest output
it should be identifying the specific constraints that a generative prompt failed to capture. we need to move toward adversarial design where we intentionally try to break the generated direction to see if it holds up under real-world stress. **if we dont, were just glorified art directors for a black box



File: 1785741729315.jpg (443.22 KB, 1024x1024, img_1785741721213_5ckm6z7v.jpg)ImgOps Exif Google Yandex

320fe No.1953[Reply]

found this breakdown on how global scale changes the game for design. it goes way beyond just tweaking things in Figma and focuses on the chaos of massive user bases
>what you learn at scale is different. does anyone else feel like edge cases become the main feature once you hit a certain size?

more here: https://uxdesign.cc/what-ive-learned-writing-for-billions-of-users-f4db0c1aa9cb?source=rss----138adf9c44c---4

320fe No.1954

File: 1785741901054.jpg (313.89 KB, 1024x1024, img_1785741886148_8clah5mb.jpg)ImgOps Exif Google Yandex

>>1953
once u hit that level, ur main job is basically managing technical debt so new features dont break legacy flows. the real challenge isnt even the UI, its ensuring the design tokens remain consistent across hundreds of different localized components.



File: 1785662234149.jpg (173.63 KB, 1024x1024, img_1785662193888_rwkvs0fb.jpg)ImgOps Exif Google Yandex

d3b32 No.1949[Reply]

just saw a great breakdown on how airlines are ditching static interfaces. instead of hunting through menus, the app surface changes based on ur location and flight status. its all about reducing cognitive load when youre rushing through security. i was sketching some similar logic in Figma earlier today and realized how much we ignore user intent during high-stress moments. it turns out most travel apps are just digital paperweights until you hit the gate .
>the boarding pass should find you, not the other way around.
is anyone else working on similar dynamic states for real-time environments?

found this here: https://uxdesign.cc/why-airlines-are-finally-waking-up-to-context-aware-design-9cdb67722d03?source=rss----138adf9c44c---4

d3b32 No.1950

File: 1785662953986.jpg (134.27 KB, 1024x1024, img_1785662913822_1n2lg1tn.jpg)ImgOps Exif Google Yandex

>>1949
the hardest part is managing the edge cases when the location data fails or the connection drops. how are you handling the transition from dynamic states back to a fallback UI ?



Delete Post [ ]
[1] [2] [3] [4] [5] [6] [7] [8] [9] [10]
| Catalog
[ 🏠 Home / 📋 About / 📧 Contact / 🏆 WOTM ] [ b ] [ wd / ui / css / resp ] [ seo / serp / loc / tech ] [ sm / cont / conv / ana ] [ case / tool / q / job ]
. "http://www.w3.org/TR/html4/strict.dtd">