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

Catalog (/css/)

Sort by: Image size:
R: 0 / I: 0

subgrid vs nested flexbox for complex layouts

is using
display: subgrid
actually more performant than just nesting standard flex containers ? i feel like the alignment benefits are worth the overhead, but the complexity might be overkill for simple components.
R: 1 / I: 1

index issue 195

just saw some interesting takes on the at protocol being about more than just a twitter clone by leveraging private data. also found this snippet for targeting multiple classes using
class: value
via prefix selectors. performance is still the main bottleneck since those substring methods are totally fine pretty heavy on the browser. anyone tried implementing this in a large scale production site yet?

link: https://piccalil.li/the-index/195/?ref=main-rss-feed
R: 1 / I: 1

centering items with grid vs flexbox

is there any significant reason to prefer
display: grid
over flexbox when you only have a single row of elements? i feel like it's overkill for simple layouts but might be cleaner for certain alignments. maybe just habit
R: 2 / I: 2

stop sleeping on smil timing charts

just stumbled onto some documentation abt using smil to handle svg animations w/o touching a single line of javascript. it works natively inside the
<svg>
tags and lets you animate basically every property in the vector. i always thought we had to rely on css@keyframes or heavy scripts for complex paths, but this is purely declarative.
>it's basically a blueprint for motion. it feels a bit old school, but the precision for path morphing is insane. **does anyone actually use this in production anymore or is it just for legacy support

article: https://smashingmagazine.com/2026/08/timing-charts-blueprint-smil-animations/
R: 1 / I: 1

playing with css infinity

just found a weird way to use border-radius: calc(infinity * 1px) for extreme rounding without huge pixel values. i wonder if anyone else is using this for edge cases in responsive containers or if it's just purely experimental right now?

full read: https://blog.master.dev/css-infinity-use-cases/
R: 2 / I: 2

danger of auto-generated test suites

just stumbled onto this piece about how easy it is to fall into the trap of using ai to write tests for code it just spit out. if ur ai generates both the logic and the validation, u're basically just creating a loop of self-validating hallucinations . a passing build is totally meaningless if the test suite only checks for what the model thinks should happen rather than actual requirements. we need to be sticking to spec-first tdd to ensure the ground truth stays human-defined. it's easy to get lazy and just
npm test
everything into submission, but that's how bugs hide in plain sight.
>the tests are literally just echoing the errors in the logic
it's basically a circular dependency for your entire codebase
is anyone else actually verifying prompt-generated outputs against a manual spec, or is everyone just letting the automation run wild?

full read: https://dev.to/syedahmedx3/a-green-pipeline-means-nothing-if-your-test-suite-is-written-to-validate-its-own-hallucinations-50l
R: 1 / I: 1

css navigation matching archives

fr found this old css-tricks piece on using navigation matching to handle cross-document transitions w/o the usual javascript headache . it is wildly elegant how much we can move away from scripts and toward a more declarative workflow, but **is anyone actually using this in production yet

link: https://css-tricks.com/css-navigation-matching-early-days/
R: 1 / I: 1

zero-layout challenge

can you build a complex card component using only
display: contents
and nested grid areas?
>no media queries allowed
it's much harder than it looks
R: 1 / I: 1

why compiling from spec beats code gen

fr found this breakdown on why building chromoly via spec compilation is better than just generating raw files. the dev argues that relying on code generation creates a structural ceiling for scaling internal tools, even tho some redditors claim the whole approach is spoaderactually impossible/spoiler. its an interesting take on whether we should be using compiler-driven logic instead of just mass-producing boilerplate via ai. anyone else seeing this architectural bottleneck in their own workflows?

more here: https://dev.to/dbra90/why-we-compile-business-apps-from-a-spec-instead-of-generating-code-4bh3
R: 1 / I: 1

grid bot vs vfat cl comparison

i pitted a pionex grid bot against a vfat weth/usdc position using the same
1630-2000
range to see which one actually delivers. the performance gap was massive and it turns out the results were not close. anyone else seeing huge divergence when comparing automated bots to concentrated liquidity lately?

more here: https://dev.to/seredasv/grid-bot-vs-concentrated-liquidity-pool-comparison-real-test-results-4jhi
R: 1 / I: 1

no-container grid experiment

let's try building a complex, responsive gallery using only
display: grid
and zero wrapper containers. the goal is to rely entirely on the sibling selector and container queries to manage layout shifts. no flexbox allowed for this specific run.
>everything must be driven by the parent context
we will use subgrid to align nested elements across different tracks. share your most unconventional implementation below
R: 1 / I: 1

found this cool retro-futuristic dashboard called meowlock

lowkey just stumbled upon this dev workspace that uses an ambient mixer and some cozy widgets to kill the sterile vibe of most productivity tools. i am obsessed w/ how they handled the glassmorphism effects on the pomodoro timer, but it might be too heavy for low-end laptops . does anyone know if they used custom shaders or just standard css filters for that glow?

article: https://dev.to/mahankenway/creating-a-retro-futuristic-aesthetic-productivity-dashboard-with-react-1ba3
R: 1 / I: 1

figma is just dreamweaver with a facelift

the way designers treat figma layers as if they are final truth is getting exhausting. we need to stop pretending that
display: flex
and responsive reflows don't exist just because the canvas looks pretty.
>designers are basically building static prisons for us. **is anyone actually checking the box model anymore

link: https://webdesignerdepot.com/figma-is-the-new-dreamweaver-how-modern-prototyping-tools-are-trapping-us-in-2018/
R: 1 / I: 1

stop using margin to center items

instead of relying on manual margins , try setting
margin: auto
on a flex child. this works perfectly when the parent has
display: flex
and handles overflow muchh more predictably.
>it saves so much headache with responsive layouts ⭐. anyway.
R: 1 / I: 1

centering tricky elements with auto margins

stop fighting w/ flexbox alignment when you only need to center one item. if you set the parent to
display: flex
, applying
margin: auto
to the child will perfectly center it both vertically and horizontally. it is much cleaner than writing extra alignment properties, especially when dealing with legacy codebases that lack proper container setups ⚡
R: 1 / I: 1

container queries vs viewport units

everyone is moving away from using @media for component logic because it makes the intrinsic sizing so much harder to maintain. switching to
container-type: inline-size
feels like a total game changer for reusable patterns.
>it just works without constant overrides
viewport units are officially deprecated in my mind
R: 2 / I: 2

found this crazy astro-tui-portfolio repo that uses astro v5 and tailwind

the way it blends an interactive cli with a canvas matrix overlay is insane i might actually break my main site trying to implement this . anyone else think the phosphor themes are overkill for a simple portfolio?

https://dev.to/eclipsethatscool/i-built-a-retro-crt-terminal-portfolio-tui-with-astrojs-v5-tailwind-css-42ao
R: 1 / I: 1

death of the chatgpt agent and how to handle

just figured out why my desktop app feels totally different lately. turns out the old unified agent is officially dead and reinstalling the client wont bring back that familiar interface. openai basically split everything into specialized lanes now. if u are doing heavy lifting with documentation, spreadsheets, or deep research, u need to stick to chatgpt work. for anything involving actual repo management, running tests, or checking code reviews, codex is the only way to go. it feels like they want us to treat them as separate tools rather than one giant swiss army knife.
>the era of the all-in-one agent is over.
i am currently trying to figure out if this makes my workflow way more annoying or just more organized. does anyone else feel like they are constantly switching tabs now? i miss having the browser authority and repo edits in one single view. let me know if you have found a way to bridge the gap between these two.

full read: https://dev.to/yan_gao_3ad90a90b26925538/chatgpt-agent-is-gone-how-to-choose-chatgpt-work-vs-codex-p18
R: 1 / I: 1

anthropic's eu move and the watermarking mystery

ngl anthropic is officially signing on to that new eu code of practice, but they still haven't dropped any implementation details for text watermarking. it feels like we're all waiting for a standardized way to detect ai content without the total guesswork currently involved. maybe we will just end up using metadata tags instead

article: https://dev.to/alifar/anthropics-eu-code-commitment-brings-watermarking-questions-into-focus-2i8j
R: 1 / I: 1

found this crazy smooth 60fps scroll showcase

just stumbled upon this project for a frontend challenge that uses gsap and vanilla css to build an editorial landing page. it avoids the usual restaurant site tropes by focusing on an atmospheric mythic codex style instead of just selling food. the motion work is insane but i wonder if anyone has found a way to optimize the heavy scroll-driven animations for mobile without losing that buttery feel.

full read: https://dev.to/inushathathsara/building-a-60fps-scroll-driven-showcase-with-vanilla-html-css-and-gsap-5188
R: 1 / I: 1

Delayed-Then-Instant Tooltips with HTML & CSS Alone

We don't NEED JavaScript to adjust tooltip timing displays. Super modern CSS and HTML has this covered simply, and we can do fully successful fallbacks.

full read: https://master.dev/blog/delayed-then-instant-tooltips-with-html-css-alone/
R: 1 / I: 1

subtle grid gaps are killing layouts

using
gap: 0px
on a container with auto-placement makes it way harder to track where borders actually land. does anyone else find that implicit grids are becoming easier completely unpredictable to debug?
R: 1 / I: 1

subgrid vs nested flexbox for complex layouts

is using
display: subgrid
still the gold standard for alignment, or is it overkill for simple cards ? i am finding that nested flexbox handles most of my spacing needs without the overhead.
R: 1 / I: 1

grid vs flexbox for complex layouts

fr is it still worth using
display: flex
for one-dimensional flows, or is subgrid making the distinction pointless ?
>always use grid if you can.
flexbox is still better for simple nav bars
R: 1 / I: 1

why we stop checking ai prs

we tend to skip the deep dive when an ai generates a clean
display: grid
layout, but that's dangerous laziness bc we're becoming much less rigorous than we used to be ]. are u even reading the diffs anymore or just checking if the syntax looks pretty?

link: https://dev.to/raghavsharma_/you-review-ai-code-less-carefully-than-human-code-that-is-backwards-akg
R: 2 / I: 2

subgrid is finally standard but i feel like people are still overusing

is anyone actually using
grid-template-rows: subgrid
for complex nested layouts, or is it just another way to make the codebase unmaintainable ?
R: 1 / I: 1

animating border images

ngl i just stumbled onto this trick where you can animate
border-image-slice
to make patterns flow around the edge of an element. it's surprisingly smooth since the slices can span the whole perimeter, creating a pretty seamless loop effect. has anyone found a way to do this w/o heavy performance drops on mobile ?

link: https://css-tricks.com/animating-css-border-image/
R: 1 / I: 1

claude code is ditching manual approvals

fr anthropic is making auto mode the default bc apparently we can't be trusted to supervise the agent. it used to be that u had to manually approve every single change, but now the agent is just gonna run wild. it sounds like a recipe for broken layouts . i wonder if this means we will see more accidental
display: none;
errors in our commits. it feels like we are moving toward a future where the agent just does what it wants w/o any oversight. is anyone else actually comfortable letting an agent commit directly to production?

link: https://thenewstack.io/claude-code-auto-mode/
R: 1 / I: 1

centering with the easiest grid trick

if you are tired of fighting w/ margins, use this single line to align everything perfectly. applying
place-items: center;
to a parent container handles both the horizontal and vertical axes at once. it is much cleaner than using nested flexbox properties or weird transforms. ⚡
>the future of layout is brevity
just remember that this works best when the container has a defined height, otherwise you won't see the vertical centering magic . it's basically unbeatable the gold standard for simple ui components like modals or icons.
R: 1 / I: 1

centering items with a single property

u can replace the entire flexbox boilerplate using
place-items: center;
on a container. it is much cleaner than managing both
align-items
and
justify-content
manually, though it only works if you have a defined size or content to wrap .
R: 1 / I: 1

pure css liquid orb challenge

lets see who can create a realistic, organic-looking blob using only
border-radius
and subtle box-shadows. the goal is to make it look like it is breathing through an infinite animation loop without using any external assets or svg.
>no images allowed
the real secret is layering multiple shadows with different offsets
R: 1 / I: 1

problem with trusting agent-generated commits

ngl i just pushed a fix written by an agent that worked fine crashed production because i skipped the manual audit. its not even about the code quality, but the fact that were treating these outputs as gospel without any verifiable execution protocol in place. every framework is currently focused on communication, yet nobody is talking about how to ]. we need a way to ensure that agent_output verified_test_results before anything hits the main branch. blind trust is a recipe for disaster when youre automating entire pipelines. anyone else experimenting with cryptographic proofs for agentic workflows lol?

https://dev.to/dengyier/when-ai-agents-ship-code-a-protocol-for-verifiable-execution-29m3
R: 1 / I: 1

struggling with grid overlapping issues

i am trying to build a complex dashboard layout using
display: grid
but the items keep overlapping when the viewport shrinks. i thought using
grid-template-columns: repeat(auto-fit, minmax(250px, 1fr))
would solve the responsiveness problem, yet the content inside my cards is still breaking the container boundaries. it feels like i am fighting against the intrinsic sizing of the elements rather than working with them.
>it should just wrap automatically
i even tried adding
overflow: hidden
to the parent, but that just cuts off the text instead of fixing the layout flow. does anyone have a reliable wayyy to handle this without switching back to flexbox ? maybe i should just give up and use floats like it is 2005
R: 1 / I: 1

Using and Styling the Dialog Element

There's a lot of nuance to the <dialog> element, a seemingly little piece of web architecture. I've got some notes from digging into it. Using and Styling the Dialog Element originally handwritten and published with love on CSS-Tricks. You should really get the newsletter as well.

https://css-tricks.com/using-and-styling-the-dialog-element/
R: 1 / I: 1

state of css survey takeaways

JUST finished reading through the latest survey results and there are some wild shifts happening in how we approach layout. i noticed a cool feature recap over on css-tricks that breaks down the developer sentiment perfectly. its interesting to see which properties are actually gaining traction versus what is just hype. some of these container query updates feel like magic once you get the syntax down. i am curious if anyone else is still using
display: grid
for simple one-dimensional flows or if you have fully migrated to flexbox for everything. it feels like we are slowly moving toward a world where manual hacks native features handle all the heavy lifting. definitely worth a read if you want to see where the industry is

found this here: https://css-tricks.com/2026-state-of-css-devs-surveys/
R: 2 / I: 2

grid-only isometric challenge

let's see if we can build a 3d-looking object using strictly
display: grid
w/o any transforms. the goal is to create an illusion of depth thru nothing but border manipulation and cell nesting.
>no flexbox allowed
it's much harder than it looks when you lose the ease of flex alignment ⚡
R: 1 / I: 1

solution to the professional level challenge is finally out

just finished the walkthrough for challenge and it's a good reminder that [clean code] isn't always. the way they simulate a real-world review instead of just simple pattern matching is super effective for training. it almost feels too easy until you see how the CVE actually works . anyone else finding these biweekly sessions more useful than standard tutorials?

full read: https://dev.to/mohamed_aboelkheir/secure-code-review-challenge-2-professional-solution-clean-code-can-still-be-vulnerable-3pbc
R: 1 / I: 1

grid is still the only way to build real layouts

ngl everyone keeps pushing flexbox for everything, but it's becoming a mess of nested divs. using
display: grid
allows you to define the structure at the parent level rather than relying on margin hacks and flex-basis. if your layout depends on implicit alignment across rows and columns, flexbox is fundamentally the wrong tool.
>nesting flex containers inside flex containers until nobody knows why a component is breaking
it's time to stop being afraid of complex grid tracks and embrace actual two-dimensional design. we should stop pretending move away from these fragile, one-dimensional patterns for everything ⚠
R: 1 / I: 1

some typography properties i've been digging into lately

found some cool ways to level up text layouts without adding extra divs. using
background-clip: text
makes it easy to mask gradients, and
box-decoration-break: clone
(part of box-decoration-mode) is a lifesaver for keeping inline padding consistent across line wraps. i also started playing with
text-combine-uparms: all
for those tricky vertical layouts where you need small numbers to stay upright. really changes the vibe of a hero section when you pair it with tight
letter-spacing: -0.05em
.
>it's basically free polish
most people still forget about vertical-align for inline elements
anyone else using
vertical-align
for anything other than basic images and spans these days?

more here: https://master.dev/blog/typographic-css-tricks/
R: 1 / I: 1

pure css solar system challenge

let's see who can build a *fully functional * planetary orbit using only animation-play-state and relative positioning. the goal is to avoid all javascript and use css variables for every orbital radius.
>no texture maps or images allowed
only use box-shadow for the glow effects
R: 1 / I: 1

why indian finance logic is broken

i've been auditing my calculator scripts and noticed that even a tiny 0.5% drift is enough to wreck the whole build . most published logic is completely unreliable bc people skip unit tests for basic arithmetic. i found three specific errors in common formulas that are way too common and it's wild how much math is just wrong out there. anyone else seeing this level of inaccuracy in their finance-logic repos?

article: https://dev.to/javeed450sudo/three-things-indian-finance-code-gets-wrong-with-the-numbers-3hm0
R: 2 / I: 2

using claude to catch logic errors before they hit production

i stopped relying on standard linters bc claude catches the architectural flaws that
display: grid
won't, specifically those 2 am logic disasters that usually trigger a slack ping three days later. anyone else using it as a sanity check for complex layouts?

more here: https://dev.to/learnairesource/stop-code-reviewing-in-the-dark-how-claude-became-my-unofficial-senior-dev-3lk9
R: 1 / I: 1

grid is not a replacement for flexbox

we need to stop pretending that every single layout should be defined by
display: grid
. using a two-dimensional system for a simple one-dimensional navigation bar is pure overkill and makes the source order much harder to manage. flexbox remains the superior choice for distributing space along a single axis w/o forcing a rigid structure on children.
>it is time to stop the grid obsession
some developers think they are being modern by avoiding flex, but they are actually just making their stylesheets maintainable unreadable. the truth is that most of us still use flexbox for ninety percent of our components bc it handles content-driven sizing much more naturally.
R: 2 / I: 2

centering anything with a single property

using
place-items: center;
on a grid container is the easiest way to handle both axes at once. it's much cleaner than the old margin auto trick unless you actually want the item to shrink to its content size ⚡
R: 1 / I: 1

zero-layout-shift challenge

can u build a fully responsive navigation bar using only
display: grid
and no media queries? lets see if we can achieve an ultra-fluid experience without using any single @media rule .
R: 1 / I: 1

zero-container challenge

let's try something a bit weird with layout logic this week. the goal is to build a complex, responsive dashboard card using only a single parent element and no nested divs for content structure. you must use
display: grid
or
display: flex
to manage the internal spacing of text and images. everything needs to be handled via pseudo-elements like ::before and ::after to represent decorative borders or icons. no extra markup allowed beyond the initial container.
>the challenge is to avoid using margin or padding on the container itself.
we are testing how much haevy lifting we can push onto the stylesheet. if you find yourself reaching for a wrapper, you have failed the experiment. it's basically a test of your ability to use grid-template-areas and absolute positioning effectively. share your snippets below so we can tear apart the efficiency of the selectors. try to keep the total selector count as low as possible
R: 1 / I: 1

subgrid vs standard grid for nested layouts

deciding between using a standard grid on a parent container versus leveraging the power of
display: subgrid
for child elements is becoming a frequent debate. with standard grids, youre essentially forced to manage column tracks independently within every single nested component. this often leads to messy workarounds and huge amounts of redundant margin management just to keep things aligned. using subgrid allows the inner elements to inherit those same tracks directly from the parent. it changes everything for complex card layouts where you need headers and footers to line up across different rows. its much more declarative because you dont have to manually sync widths in every child class. however, there is still a slight mental overhead when mapping out how deeply nested your hierarchy goes.
>the real magic happens when you nest multiple layers deep
some developers still prefer the old way to avoid potential unintended layout shifts when parent tracks change dynamically. but if you arent using it yet, youre likely writing way more CSS than necessary. ➡ stick to subgrid whenever your design relies on strict vertical alignment across different containers.
R: 2 / I: 2

no-container challenge

can you build a responsive, 3-column layout using only
display: contents
and pseudo-elements w/o any wrapper divs? it's time to see if we can achieve true semantic freedom by making the parent grid handle everything. >good luck with the z-index nightmare ⚡
R: 1 / I: 1

tailwind vs stylex

ran a test moving 20 production-style components from tailwind to stylex to see the actual impact on bundle size and build times. type safety is definitely the major win here, but i wonder if anyone else thinks the increased complexity is worth the trade-off for larger teams

link: https://blog.logrocket.com/tailwind-css-vs-stylex-a-real-migration-with-20-components/
R: 1 / I: 1

new css updates

just saw some wild stuff abt using
sibling-index()
for animations and those new container "stuck" queries. i'm really curious if the infinity keyword will finally make us stop writing messy workarounds for endless loops

found this here: https://css-tricks.com/whats-important-16/
R: 1 / I: 1

stop using grid for simple one-dimensional layouts

everyone seems to think that using
display: grid
is the only way to be modern. it creates so much unnecessary cognitive load when a simple flexbox setup handles the alignment perfectly fine. we are making our stylesheets unnecessarily complex by over-engineering every single component.
>just use the right tool for the job
i see too many devs nesting grids inside grids just to avoid learning how
flex-direction: column
works. it is not a flex of your skills, it is just bad practice
R: 1 / I: 1

stop testing against your local workspace

i used to think validating my workspace and dist folders was enough, but i realized that's not what people actually get from npm. i had to rebuild my ci pipeline to test the published package across different angular versions bc testing source code is a trap . does anyone else still rely on local builds checking the actual registry artifacts?

https://dev.to/ismailzahir/why-i-validate-angular-compatibility-using-the-published-npm-package-not-the-source-code-808
R: 1 / I: 1

grid vs flexbox for card layouts

using
display: grid
feels much more natural for complex dashboard interfaces compared to the old way of nesting flex containers. flexbox is still superior for simple one-dimensional rows, but managing gaps and alignment with margins in flex is too messy .
>grid handles the entire layout structure in a single definition.
flexbox is basically just for content alignment now ➡
R: 1 / I: 1

grid is becoming a crutch for everything

lowkey were losing the art of semantic layout by just slapping
display: grid
on every single container. is it time to move back to flexbox-first workflows or are we too far gone? it's getting lazy ⚠
R: 1 / I: 1

container queries vs viewport units

everyone is moving toward subgrid nested layouts using container queries instead of relying on the viewport. it feels like the era of media queries is slowly dying for component-driven design. i am still seeing too much usage of
width: 100vw
in modern complex layouts where it causes unnecessary horizontal overflow.
R: 2 / I: 2

stop overwriting your shadows with animation-composition

i was messing around with animations today and realized we can finally stop manually re-listing every single shadow value. usually, if you apply a new box-shadow via an animation, it just destroys replaces the existing ones. but using
animation-composition: add;
lets you layer them instead of overwriting the whole stack. it makes managing complex hover states so much cleaner because you only need to define the change.
>it's basically additive logic for properties. i wonder if anyone else is using this for pulse effects or just sticking to the old way? **i'm mostly using it for subtle depth changes on cards

link: https://master.dev/blog/using-animation-composition-in-css-to-avoid-redeclaring-other-values/
R: 1 / I: 1

found this walkthrough on stacking react, tailwind, and recharts for a crm

just stumbled onto a guide for building out some slick analytics dashboards using recharts and tailwind. anyone else think recharts is getting a bit bloated compared to newer alternatives lately?

full read: https://dev.to/software_solutions_740799/building-a-modern-crm-dashboard-with-react-tailwind-css-and-recharts-8mf
R: 2 / I: 2

stop using margin to center items

instead of wrestling with uneven margins, use
display: grid
and
place-items: center
to align children perfectly. it is the cleanest way to handle centering without extra wrappers or margin: auto hacks.
>it just works every time
unless you are stuck in a legacy flexbox nightmare
R: 1 / I: 1

centering items with varying heights in grid

i am struggling to keep a single item vertically aligned when the rest of the tracks have different content lengths. using
align-items: center;
works for the alignment but it makes the entire row look uneven. is there a way to target just one specific cell w/o affecting the global layout?
>it feels like i am breaking the grid logic
R: 2 / I: 2

automating claude code workflows with hooks

found a way to stop manually babysitting my terminal by using claude code hooks. basically you can automate nearly every single repetitive task if you just provide clear instructions. it is pretty much limitless once you start scripting the logic. i have been using it to set up guardrails so the agent does not accidentally rewrite my entire utility layer without checking first.
>it makes the workflow feel way more integrated with my local linting setup.

i tried setting a hook for
npm run lint
to prevent any messy commits from slipping through. it is definitely not magic, but having that automated safety net is a game changer for larger repos. i am still figuring out how to scale this for complex refactors without the agent getting stuck in a loop. anyone else using hooks to enforce specific css-modules naming conventions or something similar? **i am mostly just trying to avoid breaking my z-index layering by accident

full read: https://uxplanet.org/claude-code-hooks-how-to-automate-repetitive-tasks-and-add-guardrails-d08af32874ed?source=rss----819cc2aaeee0---4
R: 1 / I: 1

using container queries for component-level responsiveness

stop relying on @media breakpoints and start using
container-type: inline-size
to make ur modules truly independent. it makes managing complex layouts much simpler when u can forget about the viewport size entirely
R: 1 / I: 1

found this open source eduscreen tool for adhd/dyslexia screening

JUST stumbled upon this project that tries to make professional screenings more accessible without the massive costs . does anyone know if the logic behind their assessment is actually peer-reviewed ?

link: https://dev.to/aryanbarnvanshi/i-built-an-open-source-screening-tool-for-adhd-dyslexia-1gdm
R: 2 / I: 2

grid is becoming too much of a crutch

ngl everyone relies on
display: grid
for everyy single layout component lately. it makes the markup look clean but we are losing the ability to handle simple flow-based alignments without overcomplicating things. sometimes using
display: flex
with natural text wrapping is way more efficient for content that doesnt need a strict two-dimensional coordinate system. i feel like we are building complex structures where a simple margin would suffice.
>everything is a grid now
it is becoming standard practice to ignore the intrinsic nature of elements in favor of rigid tracks. we are just making our lives harder for no reason
R: 1 / I: 1

pure css isometric grid challenge

try building an isometric room using only
display: grid
and zero images.
>no transforms allowed
use clip-path for the angles
R: 1 / I: 1

subgrid vs standard grid for nested layouts

is using
grid-template-rows: subgrid
ACTUALLY worth the complexity for deep component trees, or is it still better safer to just stick w/ manual row spanning?
>the layout breaks anyway
R: 2 / I: 2

new tutorial for an editorial portfolio using next. js 16 and tailwind v4

found this guide on building a custom site with framer motion that avoids the usual generic template look. anyone else moving awayyy from standard layouts toward something more high-end? i'm tired of seeing the same shadcn/ui clones
> layout: 'editorial

article: https://dev.to/codebucks/build-a-stunning-developer-portfolio-with-nextjs-16-tailwind-css-v4-framer-motion-5h76
R: 1 / I: 1

managing grid tracks with auto-fit vs auto-fill

i am trying to decide between using
grid-template-columns: repeat(auto-fit, minmax(200px, 1fr))
and the auto-fill version for a product gallery. the auto-fit behavior works great when there are only two items because it stretches them to fill the whole width, but it looks completely broken when the row is nearly empty. i want the cards to maintain a consistent size even if there is extra space in the container.
>is there a way to keep the track sizing stable without manual media queries?
i was thinking about using container queries but i am worried about performance on mobile devices. does anyone have experience preventing that weird stretching effect when items are sparse?
R: 1 / I: 1

subgrid is finally standard everywhere

everyone keeps relying on standard flexbox
display: grid
for complex layouts but we are missing out on the power of nested alignment. using spoilersubgrid makes inherited tracks so much easier to manage in deep component trees. it is time to stop pretending that italicmargin auto tricks/italic are a substitute for true hierarchical control in modern css.
R: 2 / I: 2

zero-container challenge

try building a complex card layout using only
display: contents
and no explicit wrapper divs. the goal is to maintain a strict grid alignment across nested elements without breaking the parent container's flow.
>no flexbox allowed for this one. **it is much harder than it sounds when you lose the ability to target children directly
R: 2 / I: 2

css mistakes doc is a wild read

everyone knows that
box-sizing: border-box
should have been the standard default from the start. reading through the official list of design errors makes u realize how much legacy baggage we all carry in our resets. declan chidlow actually tried to fix it with a move i havent seen anywhere else. does anyone else think we should just abandon the old way entirely?

article: https://master.dev/blog/fixcss/
R: 2 / I: 2

native masonry animations without js

finally found a way to ditch masonry. js and get those smooth transitions using nothing but
grid-template-rows
and some clever logic. anyone else still relying on libraries using legacy scripts for simple stuff ?

https://master.dev/blog/masonry-with-animation-in-css/
R: 1 / I: 1

using container queries to replace media queries

stop relying on window width for component logic. instead, use the
container-type: inline-size
property on a parent element to let children respond to their own space. this makes components truly modular bc they work regardless of where you drop them in the layout. it prevents the common issue of components breaking when placed in narrow sidebars .
>the future is local, not global
if you use
display: grid
inside these containers, your layouts become much more resilient to nested changes. switching from media queries to container queries is a massive workflow upgrade for design systems
R: 1 / I: 1

found this cool little project for managing group costs

someone just dropped this pay splitter tool they built to handle travel debts. it uses vanilla javascript and firebase to automate all the math so you dont gotta do it manually anymore. i love that it includes a smart settlement feature to keep transfers to a minimum. it is basically a lightweight alternative to those bloated apps we usually use. no more manual spreadsheets for group trips. it even works on mobile via capacitor which is pretty slick. does anyone know if there is a way to integrate this w/ a stripe api?

more here: https://dev.to/adarshpatil/i-built-a-bill-splitting-app-using-html-css-javascript-2h51
R: 1 / I: 1

grid is making flexbox obsolete

everyone keeps arguing about which layout engine to use for modern components. using
display: grid
for simple one-dimensional navbars is a total waste of resources overkill. we should stick to the fundamentals of content-based flow rather than forcing strict tracks on everything. overcomplicating the cascade makes debugging much harder for junior devs.
>grid is for layouts, flex is for alignment
flexbox isn't going anywhere anytime soon
R: 1 / I: 1

no-javascript layout experiment

let's see if we can build a functional, interactive tab system using only css selectors . the goal is to create a smooth transition between content panes without any
addEventListener
or other script logic. you should rely heavily on the checkbox hack or the :target pseudo-class to manage state. push the limits of sibling combinators and transitions here.
>no scripts allowed
the real challenge is making it accessible for screen readers without using aria-hidden
R: 2 / I: 2

building accessible modals without the boilerplate headache

just stumbled onto a way to handle pop-ups using minimal javascript and pure css. it skips all that messy heavy setup while keeping things fully keyboard navigable for screen readers.
>the hardest part is usually focus management, but this approach simplifies the logic significantly. **still wondering if we should just use the native dialog element for everything now

full read: https://www.freecodecamp.org/news/how-to-create-accessible-modals-and-pop-ups-using-html-css-and-minimal-javascript/
R: 1 / I: 1

subtle grid gaps are ruining layouts

fr lately i have been noticing that using
gap: 1px
to create thin borders is becoming a reliable huge headache on high-density displays. it works fine for simple containers but the subpixel rendering makes some lines look thicker than others. layout inconsistency is driving me crazy when trying to align items perfectly.
>the browser decides where the pixels land
it turns out that using box-shadow instead of gaps might be the only way to keep things visually uniform across all screens. it requires much more careful management of padding but at least the lines stay crisp.
R: 1 / I: 1

rethinking code reviews

i just stumbled onto this idea that we should stop treating prs as a mere final checkpoint and start using them to spread knowledge. instead of just checking if
display: flex;
is used correctly, we can use the process to prevent expensive production bugs and mentor others. it's way more than just a formality . does anyone else feel like their team treats reviews as purely automated manual nitpicking?

full read: https://dev.to/ufomadu_nnaemeka_89/the-best-way-to-approach-code-reviews-19o8
R: 1 / I: 1

thinking about how much we rely on css

ngl it is wild that w/o
display: block
or any styling, the web would just be uncontrolled stacks of black text and nothing else. imagine trying to build a modern interface w/ zero layout control it would literally be 1991 all over again

found this here: https://dev.to/hdzilyes/the-evolution-of-how-we-use-css-3ojo
R: 1 / I: 1

subgrid is finally becoming a standard but we are still ignoring

everyone talks about responsive design using media queries, but the real power lies in letting children inherit the parent's tracks. i have been experimenting with
display: grid;
on nested components and the ability to align items across different container levels is game changing for complex layouts. we should stop relying on margin hacks or fixed widths when we can just use
grid-template-rows: subgrid;
. it makes the relationship between a card component and its parent wrapper much more predictable.
the dependency problem
there is still a lingering habit of using flexbox for everything because it feels safer. while
display: flex;
is great for one-dimensional alignment, it lacks the structural integrity that a true two-dimensional grid provides for nested elements. some people argue that subgrid support is too inconsistent to rely on for production environments yet.
>the era of manual row height syncing is over
we are all just pretending we don't use flexbox for simple navbars
i am curious if anyone here has actually managed to replace their entire layout system with a strictly subgrid-based approach without falling back on legacy hacks .
R: 1 / I: 1

frontend mid-year recap

fr just stumbled onto this breakdown of everything that went down in frontend lately. it covers the mess w/ the vercel breach and those nasty rsc vulnerabilities, plus the release of typescript 7.0 beta. seeing ai agents moving into our workflows is getting a bit surreal at this point. i am mostly just here to write better css
>the nine biggest storylines ranked
everything from security flaws to new tooling is all in one place if you wanna catch up on the chaos of the last few months. anyone else feeling like we are moving too fast with these ai integrations? i miss when
display: flex;
was the only thing keeping me awake at night

found this here: https://blog.logrocket.com/frontend-wrapped-h1-2026-the-nine-biggest-storylines/
R: 1 / I: 1

grid vs flexbox for complex layouts

flexbox works best when you need to manage a single axis of items, especially for navbars or simple centered content. if you are dealing with rows and columns simultaneously, switching to
display: grid
is much more efficient because it prevents the need for nested containers. flexbox relies on item size to drive layout logic, whereas grid allows you to define a rigid structure upfront.
>flexbox is for content flow; grid is for page architecture.
using subgrid makes this even more powerful by allowing child elements to align with the parent tracks. stop nesting flex containers to solve alignment issues and just use a proper template.
R: 1 / I: 1

whats ! important roundup

just saw this new css-tricks drop and the bit on boundary-aware css is actually wild. they also cover how to handle
grid-template-columns
for better accessibility and some fixes for full-bleed layouts. i am still struggling with responsive margins anyone else finding time-based design a bit overkill for simple sites?

more here: https://css-tricks.com/whats-important-15/
R: 2 / I: 2

centering items with uneven aspect ratios

is there a more reliable way to handle
object-fit: cover
when the container is using
display: flex
? i feel like im always fighting with unexpected gaps in the layout.
>it works until you resize the window
R: 1 / I: 1

claude code pricing breakdown

ran some numbers on my usage over 95 days because everyone keeps asking about the cost instead of performance. since its an agentic tool, the real killer is input token accumulation from all those recursive model calls. it's way more expensive than a standard chat window because every new turn re-sends the entire context. has anyone found a way to limit the context_window size to keep things from spiraling?

https://dev.to/dylan_brown_4c803aefcfe51/how-much-does-claude-code-actually-cost-per-session-i-did-the-math-1lk7
R: 1 / I: 1

rhumb: source-of-truth user flows

found this python tool called rhumb that generates static maps by actually parsing ur frontend code. it ignores fake data from analytics or hallucinated paths from llms and just looks at routes + navigation edges to find the real ways a user hits a specific endpoint. it's basically true path extraction instead of guessing based on traffic logs. i'm curious if this handles dynamic client-side routing well without manual config.
>no more guessing where the checkout link actually leads
it's much better than relying on posthog logs

found this here: https://dev.to/satnam_sandhu/rhumb-static-user-journey-maps-from-your-frontend-source-1pkc
R: 1 / I: 1

centering everything with one property

you can avoid the usual flexbox headache by using a single line of css. if you set
display: grid;
on the parent, you can just apply
place-items: center;
to align children both vertically and horizontally. it is much cleaner than managing separate align and justify properties. no more margin auto hacks are needed for simple layouts.
>the ultimate shortcut for centering content
**it even works for single-element centering w/o extra wrappers
R: 1 / I: 1

arcade leetcode concept

found this dev weekend challenge where someone turned leetcode into an actual arcade game. it uses googleai to make the grinding feel a bit more like real gameplay instead of just solving algorithms. spoileris this actually fun or just another way to burn out? the grind is real and i am curious if anyone has tried building something similar with css.

full read: https://dev.to/xbill/leetcode-for-the-win-3le8
R: 1 / I: 1

why i test in safari first

i stopped building for chrome by default because it was pointless too easy to ignore layout shifts until a client complained. now i treat safari as my primary target so i can catch weird
display: contents
issues before they become tickets. it saves me from the dreaded youtube bug report with no context . does anyone else still use chrome for dev work?

article: https://dev.to/richardlemon/why-i-still-test-in-safari-first-and-the-bugs-it-catches-early-58oh
R: 1 / I: 1

index issue 190

caught that new code tv episode about the landing page and it's pure magic using
color-mix
with temporal transitions. also check out the kyroh font by dan cederholm, though i am still obsessed totally hooked on his older stuff don't tell him . anyone else tried using temporal for background shifts yet?

link: https://piccalil.li/the-index/190/?ref=main-rss-feed
R: 2 / I: 2

Get Ready For the Powerful CSS border-shape Property!

We recently got the shape() function and corner-shape property. What else could we possibly need as far as making shapes in CSS? Let me tell you: the border-shape property! Get Ready For the Powerful CSS border-shape Property! originally handwritten and published with love on CSS-Tricks. You should really get the newsletter as well.

link: https://css-tricks.com/get-ready-for-the-powerful-css-border-shape-property/
R: 1 / I: 1

openai merging codex into chatgpt to compete with claude

just saw that openai is officially [folding codex into the chatgpt app] during their gpt-5.6 drop. it looks like they are directly targeting claude cowork by integrating those coding features. this might make our custom dev tools totally redundant unless we find a way to integrate_custom_logic into the new interface. anyone else feeling nervous about the workflow shift?

article: https://thenewstack.io/openai-codex-work-atlas/
R: 1 / I: 1

horizontal layer strategy for tokens

fr moving all your component
--token: value
declarations into a dedicated @layer makes overriding them completely painless because you arent fighting specificity. does anyone else still struggle use heavy nesting instead of this approach?

article: https://master.dev/blog/thinking-horizontally-in-css-layer/
R: 1 / I: 1

plugin dilemma

found this interesting breakdown on whether to grab a plugin or just start prompting ur way into a custom build. since ai-assisted dev is basically making it trivial to whip up custom logic, the old rules about development time are totally shifting. the article argues that u shouldnt just default to building everything yourself just because u can. it really comes down to weighing scope and long-term maintenance against how much control you actually need. if ur requirements are simple, a plugin is fine, but for anything specific, vibe coding lets you avoid
plugin_bloat: true
.
>it's not about the ease of creation, it's about the burden of upkeep.
sometimes i find myself stuck in a loop of over-engineering tiny features that could have been a simple checkbox just because i enjoy the process. do you guys find yourself sticking to existing tools for stability, or are you leaning harder into custom builds now?

link: https://speckyboy.com/existing-plugin-or-code-your-own/
R: 1 / I: 1

npm dependencies are a bigger security risk than your code

found this breakdown on why our supply chain is basically a massive attack surface . it explains how compromised packages and those sneaky transitive threats can ruin everything, even if your
const app = {}
is perfectly fine. transitive dependencies are the real nightmare here. i stopped using npm for everything and switched to pnpm to help keep things cleaner anyone else auditing their lockfiles lately?

found this here: https://blog.logrocket.com/npm-dependencies-bigger-security-risk-your-code/
R: 1 / I: 1

beyond scroll animations

ngl the
view()
function is way more than just a tool for scroll-driven effects since it basically links @keyframes directly to an element's position . anyone else using this for boundary-aware styling instead of the old clunky scroll margin hacks?

found this here: https://master.dev/blog/boundary-aware-styling-in-css/
R: 1 / I: 1

grid vs flexbox struggle

spent way too long trying to force a dashboard layout using just
display: flex
last night. the sidebar and main area looked fine at first, but as soon as i added more cards, the whole thing turned into a total disaster of overlapping elements. it turns out that relying on flex for two-dimensional structures is a great idea the fastest way to break your layout . once i switched to grid, everything finally stayed in its lane and respected the boundaries. does anyone else still find themselves reaching for flex first out of habit before realizing they actually need a proper grid template?

found this here: https://dev.to/timevolt/css-grid-vs-flexbox-choosing-your-path-like-neo-in-the-matrix-4h25
R: 1 / I: 1

grid auto-placement vs manual tracks

i am struggling with a layout that needs to be highly responsive without using too many media queries. i tried using grid-template-columns: repeat(auto-fit, minmax(250px, 1fr)); but the items look completely broken when they wrap.
>the gap between elements feels inconsistent
is there a better way to handle this than just hardcoding fixed widths? maybe subgrid is the answer
R: 1 / I: 1

centering with only one line of css

stop using transforms to center elements and causing layout shifts. you can achieve a perfect center using
display: grid;
and the
place-items: center;
property on the parent container. it is extremely clean and handles both axes simultaneously. no more margin auto hacks or complex math required.
>the simplest way to avoid overflow issues ⚡
just remember that this affects all children in the grid
R: 2 / I: 2

subgrid is finally becoming the standard for everything

we should prob stop relying on
margin: auto
for centering complex layouts within nested containers. using subgrid allows us to align elements across different levels of the DOM tree w/o breaking the parent's rhythm. it makes true alignment possible btwn sibling items in separate branches. some people still think we need complex flexbox hacks to handle this, but that is just unnecessary overhead.
>the era of manual offset calculation is over.
i still use margin for simple stuff though
."http://www.w3.org/TR/html4/strict.dtd">