Aggregating posts from a set of RSS feeds into a time-ordered list is straightforward, in this case using the Feedzy lite WordPress plugin to pull excerpts from multiple sources. The real problem is presentation: the plugin's default output is a flat, unremarkable list, while the intent was a magazine-style page that mixes small panels with larger featured ones.
A fixed multi-column grid plus media queries to redefine it at each breakpoint would work, but only by chasing down break points by hand. Grid's auto-fit promises a fluid grid with no media queries at all — until column spans enter the picture, at which point the grid overflows on narrow screens. Published tutorials tend to fall into one of two groups: interesting layouts with spanned items but a fixed column count, or automatically resizing grids in which every item is the same width. Getting both at once takes some care, but is achievable in roughly a dozen lines plus a single media query (none, if fewer span options are acceptable).

An auto-fitting grid and its limits
Dropping the plugin's posts into a wrapper and applying a compact grid-template-columns rule is enough to get fluid behavior. Row heights adjust automatically to the tallest item in each row, and the column count moves between one and five as the container resizes.
.archive {
/* Define the element as a grid container */
display: grid;
/* Auto-fit as many items on a row as possible without going under 180px */
grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
/* A little spacing between articles */
grid-gap: 1em;
}
The mechanism is the pairing of auto-fit with minmax() on grid-template-columns. Writing repeat(5, 1fr) alone would produce five columns that shrink forever and end up unreadably narrow at small widths. minmax() instead states the minimum a column may be squeezed to and the maximum it may expand to; below the minimum the browser drops columns, above it the browser adds them. With a floor like 180px and a ceiling of 1fr, as many columns as fit at that width are created and any leftover space is divided evenly among them. When the window grows enough to accommodate another 180px column, a new column appears; shrinking reverses the process down to a single column.
Spanning items and filling the gaps
A featured item is declared with grid-column: span 2, but a wide item that does not fit the current row is pushed to the next one, leaving a hole behind. Adding grid-auto-flow: dense to the grid container tells the browser to backfill such holes with smaller items, which then flow around the featured panels. The visible cost is ordering: a later single-column item may be placed before the wide item. That trade-off comes with the technique.

span [n] is the simplest way to size an item across columns. Explicit placement with grid line numbers is also available — positive numbers count from the left edge and negative numbers from the right — and either end of the pair can be swapped for span. A three-column box can therefore be produced identically by any of grid-column: 3 / 6, grid-column: -4 / -1, grid-column: 3 / span 3, grid-column: -4 / span 3, grid-column: span 3 / -1, and so on. On a fixed-column grid these are interchangeable; once the column count can change, they diverge sharply.
Why explicit line numbers break responsive grids
Span declarations built on the full five-column layout look correct at wide widths and fall apart near two columns: the container shrinks, but the grid keeps trying to honor five columns, abandons equal-width columns to do so, and spills past its right edge, producing horizontal scrolling. The browser is doing what it was told. auto-fit would produce two implicit columns at that width, yet the same rules make explicit reference to grid line 5, and a two-column grid only offers lines 1, 2, 3 and -3, -2, -1. When implicit and explicit columns conflict, grid always defers to the explicit grid. Spans have the same effect: grid-column: span 3 forces at least three explicit columns even where two are wanted.
Media queries redefining grid-column at the breaking point are one way out, but not the only one. The useful rule is to reference only grid lines that exist in the narrowest grid the design will display — here, two columns, since very narrow screens are handled by a single media query switching to a one-column, flexbox-based layout.
@media (max-width: 680px) {
.archive {
display: flex;
flex-direction: column;
}
.article {
margin-bottom: 2em;
}
}
A span vocabulary that survives resizing
Restricting line references to 1, 2, 3 and -3, -2, -1 at first suggests a maximum span of two columns: grid-column: span 2, grid-column: 1 / 3, grid-column: -3 / -1. That stays responsive but is visually dull. Mixing a positive start with a negative end value proves far more productive, because the width of the span changes as the grid resizes. grid-column: 1 / -1 yields a full-width banner at every column count, including one column. grid-column: 1 / -2 leaves one column free at the right and contracts to a single column on narrow screens — grid will not collapse an item to zero width, so it holds at one column even at the smallest width, as 1 / 1 would. grid-column: 2 / -1 mirrors this on the right but overflows in a one-column display. 1 / -3 also holds up as a single-column item at two columns, despite start and -3 pointing at the same line.
Playing through the combinations produces eleven usable grid-column values. Three survive down to a one-column layout; seven more survive to two columns and need only the single-column media query. Notable cases: 2 / -2 makes a centered span that works down to one column; 3 / -1 is the least useful because it overflows even at two columns; 3 / -3 behaves unexpectedly well. Ten of these patterns remain available once the one-column query is accounted for, which is ample material for a varied layout.

auto-fit grid. (Demo)Repeating featured panels with :nth-child()
Keeping the CSS short depends on targeting multiple feed items with one rule. Listing selectors by comma-separated index works but is tedious to adjust and must be repeated for each styled child inside the featured panels. An equation argument to :nth-child() solves this: :nth-child(31n + 1) selects items 1, 32, 63 and so on — the browser iterates n = 0, 1, 2 … and stops when no such child exists — which is how the full-width blue panels are placed at the top of the page and roughly halfway down.
.article:nth-child(31n + 1) {
grid-column: 1 / -1;
background: rgba(11, 111, 222, 0.5);
}
The alternating purple boxes use two selectors with the same interval and different offsets: 16n + 2 for one side and 16n + 10 for the other, giving items 2, 18, 34 … and items 10, 26, 42 …. Shared styling such as background-color can be written once with 8n, since 8 is half of 16 and the offsets differ by 8, covering items 2, 10, 18, 26, 34, 42 and so forth.
Remaining gaps in the spec
Auto-fitting grids keep the code short, but positioning items without falling back on media queries is genuinely constrained. A span declaration outranks responsiveness: asked for a flexible grid and a four-column item at once, the browser honors the span and overflows on narrow screens, whereas prioritizing the grid would be preferable. The last row is a second annoyance — as widths change it is often only partly filled, and no mechanism exists to make the final item stretch across the remaining columns. A start value meaning "wherever the left edge naturally falls" would allow it; it isn't available. Layouts like this one can serve any dynamically generated content, from latest-posts widgets to archive and search results, but they inherit those limits.
.article {
grid-column: auto, -1;
}


