AGENT SKILL

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

  1. High Density: The screen is packed with information, imagery, and interactive elements.
  2. Ornate Detailing: Use of decorative borders, intricate textures, and classic design flourishes.
  3. 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 Cinzel or Playfair 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 LazyVGrid with very tight spacing (e.g., 4) creates the necessary density.
  • Extensive use of .border and .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_view to create the complex, spanning "masonry" or architectural grid layouts typical of maximalism.
  • Use Stack with Positioned.fill and Padding to 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
        )
    }
}
  • LazyVerticalGrid with GridCells.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

Marvellbrazil
Marvellbrazil/my-agentic-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".

★ 5
Marvellbrazil
Marvellbrazil/my-agentic-skills

writing-for-agents

Writing documents for agents. Use when creating or editing skills, or modifying AGENTS.md or CLAUDE.md.

★ 5
Marvellbrazil
Marvellbrazil/my-agentic-skills

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.

★ 5
Marvellbrazil
Marvellbrazil/my-agentic-skills

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.

★ 5
Marvellbrazil
Marvellbrazil/my-agentic-skills

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.

★ 5
Marvellbrazil
Marvellbrazil/my-agentic-skills

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.

★ 5