Imagem de cactus do meu Sertão nordestino

Simbora falar de Spec Driven Development?

Vixe, Maria! Se tu trabalha com desenvolvimento Android e ainda não ouviu falar de Spec-Driven Development (SDD), tu tá perdendo tempo e gastando uma energia danada feito cego em tiroteio.

Hoje em dia, com as Inteligências Artificiais batendo na nossa porta, tem muita gente gerando código de qualquer jeito, enchendo o Jetpack Compose de recomposition desnecessária e deixando o app mais pesado que uma jaca gorda.

Aquece o café, puxa uma cadeira e vem entender como juntar especificação inteligente, IA e Compose pra deixar teu app voando baixo!

O que danado é Spec-Driven Development (SDD)?

Bora simplificar: SDD é a arte de pensar antes de sair batendo teclado. Em vez de tu abrir o Android Studio e pedir pra IA “gerar uma tela de listagem”, tu cria uma especificação cirúrgica (a tal da Spec).

Uma boa Spec define:

1. O Estado da Tela (UI State): Exatamente o que a tela pode exibir (Carregando, Sucesso, Erro, Vazio).
2. Os Eventos (UI Events): O que o usuário pode fazer (Clicar, arrastar, recarregar).
3. As Restrições de Desempenho: Regras para o Compose não engasgar.

Quando tu entrega uma Spec mastigada pra IA, ela não inventa moda. Ela cospe um código limpo, direto ao ponto e focado em performance. É economia de API e de juízo!

O Pulo do Gato no Jetpack Compose: Estabilidade é Tudo!

No Compose, se tu passar um objeto que a IA gerou de qualquer jeito, o compilador pode achar que aquilo muda toda hora. Resultado? O app fica recomputando a tela toda, travando mais que burro empacado na subida da ladeira.

Pra IA te dar o código certeiro, a tua Spec precisa exigir:

• Uso de @Immutable ou @Stable nos modelos de dados.
• Uso de Remember e derivedStateOf onde for preciso.
• Passagem de lambdas para evitar que o Compose redesenhe o componente pai sem necessidade.

Na Prática: O Prompt Arretado de Bom

Não chegue na IA com conversa mole. Use um prompt estruturado, feito esse aqui:

📝 Exemplo de Prompt (A Spec)

“Atue como um Engenheiro Android Sênior especialista em Jetpack Compose e Performance. Quero que você implemente a UI de uma listagem de produtos com base na seguinte especificação:

1. UI State: > ProductListState deve ser uma sealed interface contendo: Loading, Success (com uma lista imutável de produtos) e Error (com mensagem).

2. Performance Rules (Mandatório):

• O modelo de dados do produto deve ser marcado como @Immutable
• A lista no estado Success deve usar ImmutableList da biblioteca de coleções imutáveis do Kotlin para garantir estabilidade.
• Na LazyColumn, use obrigatoriamente um key único para cada item.
• Passar eventos de clique via referência de função/lambda ((ProductId) -> Unit).

3. Tech Stack: Jetpack Compose, Material 3, Kotlin X Immutable Collections.

Gere apenas o código de UI focado em alta performance.”

O Código que a IA te Devolve (Sem Arrodeio)

Seguindo essa Spec, a IA não vai vacilar. Ela vai te entregar um código redondo, mais ou menos assim:

import androidx.compose.runtime.Immutable
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material3.Text
import kotlinx.collections.immutable.ImmutableList

// 1. Modelo estável pro Compose não se avexar
@Immutable
data class Product(
    val id: String,
    val name: String,
    val price: Double
)
// 2. Estados da tela bem definidos
sealed interface ProductListState {
    object Loading : ProductListState
    data class Success(val products: ImmutableList<Product>) : ProductListState
    data class Error(val message: String) : ProductListState
}
@Composable
fun ProductListScreen(
    state: ProductListState,
    onProductClick: (String) -> Unit, // Lambda pro Compose ficar tranquilo
    modifier: Modifier = Modifier
) {
    when (state) {
        is ProductListState.Loading -> Text("Carregando, espere um pedacinho...")
        is ProductListState.Error -> Text("Eita, deu xabu: ${state.message}")
        is ProductListState.Success -> {
            LazyColumn(modifier = modifier) {
                // 'key' garante que o Compose só recrie o item que mudou de verdade
                items(items = state.products, key = { it.id }) { product ->
                    ProductRow(product = product, onClick = onProductClick)
                }
            }
        }
    }
}
@Composable
fun ProductRow(
    product: Product,
    onClick: (String) -> Unit,
    modifier: Modifier = Modifier
) {
    // UI do item do produto aqui...
}

Viu aí? Sem essa Spec, a IA provavelmente usaria uma List padrão do Kotlin (que o Compose não assume como estável por padrão) e esqueceria o key da LazyColumn. Teu app ia rodar arrastado e tu nem ia saber o porquê.

Resumo da Ópera

Usar IA não é só dar um “Ctrl+C / Ctrl+V” no primeiro código que ela cospe. Usar IA com Spec-Driven Development é você ser o maestro da orquestra. Tu dá a diretriz certa, garante as regras de performance do Android, e ela faz o trabalho bruto no estalar de dedos. É produtivo e assertivo demais, num é não?