maximalism
Web and App implementation guide for Controlled Maximalism. Trigger when user wants lots of elements, dense content, but a highly curated and artistic presentation.
- License 许可
- MIT
- 最近更新
- 2026-10-23
- Stars
- ★ 5
- Forks
- 0
01 前言 Front Matter
- name
- maximalism
- risk
- safe
- source
- self
- date_added
- 2026-06-17
- description
- Web and App implementation guide for Controlled Maximalism. Trigger when user wants lots of elements, dense content, but a highly curated and artistic presentation.
- source_type
- self
03 SKILL.md 正文
Controlled Maximalism
"Dense and rich, but deeply intentional. Like an exquisitely curated museum of artifacts."
When to Use
Use this sub-style when the user's request matches the aesthetic described above. This is a child reference of the design-it skill and is not meant to be triggered directly.
Core Principles
- High Density: The screen is packed with information, imagery, and interactive elements.
- Ornate Detailing: Use of decorative borders, intricate textures, and classic design flourishes.
- Structured Chaos: Unlike Vibrant Maximalism, the layout here is based on a strict underlying grid that holds the massive amount of content together.
Visual DNA
- Colors: Monochromatic Brown, Yacht Club, or rich jewel tones (emerald, ruby, sapphire, gold).
- Typography: Ornate serifs (like
CinzelorPlayfair Display) paired with dense, highly legible sans-serif body copy. - Borders & Dividers: Extensive use of thin, elegant lines separating every piece of content.
Web Implementation
- Use dense CSS Grid layouts.
- CSS Example:
body {
background-color: #0F172A; /* Deep slate */
color: #E2E8F0;
background-image: url('subtle-damask-pattern.png');
}
.max-grid {
display: grid;
grid-template-columns: repeat(6, 1fr);
gap: 16px;
padding: 16px;
}
.max-item {
background-color: rgba(30, 41, 59, 0.9); /* Semi-transparent over pattern */
border: 1px solid #475569;
padding: 24px;
}
/* Ornate decorative borders */
.max-feature {
grid-column: span 3;
border: 2px solid #D4AF37; /* Gold */
position: relative;
}
.max-feature::before {
content: '';
position: absolute;
top: 4px; left: 4px; right: 4px; bottom: 4px;
border: 1px dashed #D4AF37;
}
.max-title {
font-family: 'Cinzel', serif;
color: #D4AF37;
font-size: 2.5rem;
text-align: center;
border-bottom: 1px solid #475569;
padding-bottom: 16px;
margin-bottom: 16px;
}
App Implementation
SwiftUI
struct MaximalismView: View {
let columns = [
GridItem(.flexible(), spacing: 4),
GridItem(.flexible(), spacing: 4),
GridItem(.flexible(), spacing: 4)
]
var body: some View {
ScrollView {
LazyVGrid(columns: columns, spacing: 4) {
// Feature span
MaxItem(title: "MUSEUM", isFeature: true)
// Dense data blocks
MaxItem(title: "1892")
MaxItem(title: "Vol. II")
MaxItem(title: "Arch")
MaxItem(title: "Index")
}
.padding(16)
}
.background(Color(hex: "0F172A")) // Deep slate
}
}
struct MaxItem: View {
let title: String
var isFeature: Bool = false
var body: some View {
VStack {
Text(title)
.font(.custom("Cinzel", size: isFeature ? 28 : 14))
.foregroundColor(Color(hex: "D4AF37")) // Gold
.padding()
}
.frame(maxWidth: .infinity, minHeight: isFeature ? 150 : 80)
.background(Color(hex: "1E293B").opacity(0.9))
.border(Color(hex: "475569"), width: 1)
.overlay(
// Ornate internal dashed border for the feature item
Group {
if isFeature {
Rectangle()
.stroke(style: StrokeStyle(lineWidth: 1, dash: [4]))
.foregroundColor(Color(hex: "D4AF37"))
.padding(4)
}
}
)
}
}
- A
LazyVGridwith very tightspacing(e.g.,4) creates the necessary density. - Extensive use of
.borderand.overlay(Rectangle().stroke(...))to box in every piece of data, mimicking ornate framing.
Flutter
class MaximalismScreen extends StatelessWidget {
@override
Widget build(BuildContext context) {
return Scaffold(
backgroundColor: const Color(0xFF0F172A),
body: GridView.count(
crossAxisCount: 3,
padding: const EdgeInsets.all(16),
mainAxisSpacing: 4,
crossAxisSpacing: 4,
children: [
// Flutter's standard GridView doesn't span columns easily.
// In a real app, use the `flutter_staggered_grid_view` package.
_buildItem('1892'),
_buildItem('Vol. II'),
_buildItem('Arch'),
_buildItem('Index', isOrnate: true),
_buildItem('04'),
_buildItem('XII'),
],
),
);
}
Widget _buildItem(String title, {bool isOrnate = false}) {
return Container(
decoration: BoxDecoration(
color: const Color(0xFF1E293B).withOpacity(0.9),
border: Border.all(color: const Color(0xFF475569), width: 1),
),
child: Stack(
children: [
if (isOrnate)
Positioned.fill(
child: Padding(
padding: const EdgeInsets.all(4.0),
// Requires path_drawing or custom painter for dashed borders natively
child: Container(
decoration: BoxDecoration(border: Border.all(color: const Color(0xFFD4AF37), width: 1)),
),
),
),
Center(
child: Text(
title,
style: const TextStyle(fontFamily: 'Cinzel', color: Color(0xFFD4AF37), fontSize: 16),
),
),
],
),
);
}
}
- Use
flutter_staggered_grid_viewto create the complex, spanning "masonry" or architectural grid layouts typical of maximalism. - Use
StackwithPositioned.fillandPaddingto create double-bordered framing effects.
React Native
const MaximalismScreen = () => {
return (
<ScrollView style={{ flex: 1, backgroundColor: '#0F172A' }}>
<View style={{ padding: 16, flexDirection: 'row', flexWrap: 'wrap', gap: 4 }}>
{/* Feature Item spanning full width */}
<View style={[styles.item, styles.featureItem]}>
<View style={styles.ornateInnerBorder}>
<Text style={[styles.text, { fontSize: 32 }]}>MUSEUM</Text>
</View>
</View>
{/* Small Dense Items */}
<View style={[styles.item, { width: '32%' }]}><Text style={styles.text}>1892</Text></View>
<View style={[styles.item, { width: '32%' }]}><Text style={styles.text}>Vol. II</Text></View>
<View style={[styles.item, { width: '32%' }]}><Text style={styles.text}>Arch</Text></View>
</View>
</ScrollView>
);
};
const styles = StyleSheet.create({
item: {
backgroundColor: 'rgba(30, 41, 59, 0.9)',
borderColor: '#475569', borderWidth: 1,
height: 100, justifyContent: 'center', alignItems: 'center'
},
featureItem: {
width: '100%', height: 200, padding: 4,
},
ornateInnerBorder: {
flex: 1, width: '100%',
borderColor: '#D4AF37', borderWidth: 1, borderStyle: 'dashed',
justifyContent: 'center', alignItems: 'center'
},
text: {
fontFamily: 'Cinzel-Regular', color: '#D4AF37', fontSize: 16
}
});
- A
flexWrap: 'wrap'container with percentage widths (e.g.,32%for 3 columns) is the easiest way to build complex, dense grids in React Native. - Use
borderStyle: 'dashed'combined with a solid outer border to create ornate framing.
Jetpack Compose
@Composable
fun MaximalismScreen() {
LazyVerticalGrid(
columns = GridCells.Fixed(3),
modifier = Modifier.fillMaxSize().background(Color(0xFF0F172A)).padding(16.dp),
horizontalArrangement = Arrangement.spacedBy(4.dp),
verticalArrangement = Arrangement.spacedBy(4.dp)
) {
// Feature spanning all 3 columns
item(span = { GridItemSpan(3) }) {
MaxItem("MUSEUM", isFeature = true)
}
// Dense items
items(6) { index ->
MaxItem("Item $index")
}
}
}
@Composable
fun MaxItem(title: String, isFeature: Boolean = false) {
Box(
modifier = Modifier
.height(if (isFeature) 200.dp else 100.dp)
.background(Color(0xFF1E293B).copy(alpha = 0.9f))
.border(1.dp, Color(0xFF475569))
.padding(4.dp),
contentAlignment = Alignment.Center
) {
if (isFeature) {
// Ornate inner border
Box(
modifier = Modifier
.fillMaxSize()
.border(1.dp, Color(0xFFD4AF37), shape = RoundedCornerShape(0.dp))
// Note: Dashed borders require a custom drawBehind modifier in Compose
)
}
Text(
text = title,
color = Color(0xFFD4AF37),
fontFamily = FontFamily.Serif, // Replace with custom Cinzel font
fontSize = if (isFeature) 32.sp else 16.sp
)
}
}
LazyVerticalGridwithGridCells.Fixed(3)is perfect.- Use
GridItemSpan(3)for the hero elements to make them span the full width, mimicking editorial or museum layouts.
Do's and Don'ts
- DO: Treat every pixel as valuable real estate. Frame everything.
- DON'T: Let it become unreadable. The contrast between text and background must remain high despite the density.
Limitations
- This is a styling reference and does not replace environment-specific validation, accessibility testing, or expert review.
- Ensure appropriate contrast ratios and responsive behaviors are verified separately.
04 同仓库更多 Skills
writing-guidelines
Review docs/prose for Writing Guidelines compliance. Use when asked to "review my docs", "check writing style", "audit prose", "review docs voice and tone", or "check this page against the writing handbook".
writing-for-agents
Writing documents for agents. Use when creating or editing skills, or modifying AGENTS.md or CLAUDE.md.
wrangler
Cloudflare Workers CLI for deploying, developing, and managing Workers, KV, R2, D1, Vectorize, Hyperdrive, Workers AI, Containers, Queues, Workflows, Pipelines, and Secrets Store. Load before running wrangler commands to ensure correct syntax and best practices. Biases towards retrieval from Cloudflare docs over pre-trained knowledge.
workers-best-practices
Reviews and authors Cloudflare Workers code against production best practices. Load when writing new Workers, reviewing Worker code, configuring wrangler.jsonc, or checking for common Workers anti-patterns (streaming, floating promises, global state, secrets, bindings, observability). Biases towards retrieval from Cloudflare docs over pre-trained knowledge.
web-perf
Analyzes web performance using Chrome DevTools MCP. Measures Core Web Vitals (LCP, INP, CLS) and supplementary metrics (FCP, TBT, Speed Index), identifies render-blocking resources, network dependency chains, layout shifts, caching issues, and accessibility gaps. Use when asked to audit, profile, debug, or optimize page load performance, Lighthouse scores, or site speed. Biases towards retrieval from current documentation over pre-trained knowledge.
using-agent-skills
Discovers and invokes agent skills. Use when starting a session, or when you need to decide which skill or workflow applies to the piece of work at hand. This is the meta-skill that governs how all other skills are discovered and invoked.