Building a Claude Code Plugin from Scratch: DroidForge as a Case Study

plugin.json

DroidForge/
├── plugin.json          # Manifest — name, version, skills declared
├── skills/
│   ├── SKILL.md         # Auto-discovery index (required)
│   ├── new-android-project.md
│   ├── signing-setup.md
│   ├── version-bump.md
│   ├── gradle-dsl.md
│   └── scaffold-screen.md
├── hooks/
│   └── security-scan.py
└── README.md

{
  "name": "DroidForge",
  "version": "1.2.0",
  "description": "Android build workflow engine — signing, versioning, Gradle DSL, MVVM scaffolding",
  "author": "SUDARSHANCHAUDHARI",
  "skills": [
    "skills/new-android-project.md",
    "skills/signing-setup.md",
    "skills/version-bump.md",
    "skills/gradle-dsl.md",
    "skills/scaffold-screen.md"
  ],
  "hooks": [
    {
      "event": "PreToolUse",
      "automation": ["Write", "Edit", "MultiEdit"],
      "command": "python3 hooks/security-scan.py"
    }
  ]
}

---
name: scaffold-screen
description: Scaffold a new Jetpack Compose screen with ViewModel, sealed UiState,
             and Hilt injection. Use when adding any new screen to an Android app.
---

# Scaffold Screen

## When to use
When the user says "add a [name] screen" or "create a new screen for [feature]".

## Output

Create these files:

### 1. Screen Composable
Path: `presentation/ui/screen/[feature]/[Feature]Screen.kt`

```kotlin
@Composable
fun [Feature]Screen(
    viewModel: [Feature]ViewModel = hiltViewModel(),
    onNavigateBack: () -> Unit
) {
    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
    [Feature]Content(
        uiState = uiState,
        onAction = viewModel::onAction,
        onNavigateBack = onNavigateBack
    )
}

@Composable
private fun [Feature]Content(
    uiState: [Feature]UiState,
    onAction: ([Feature]Action) -> Unit,
    onNavigateBack: () -> Unit
) {
    when (uiState) {
        is [Feature]UiState.Loading -> LoadingScreen()
        is [Feature]UiState.Success -> { /* content */ }
        is [Feature]UiState.Error -> ErrorScreen(
            message = uiState.message,
            onRetry = { onAction([Feature]Action.Retry) }
        )
    }
}

presentation/viewmodel/[Feature]ViewModel.kt

@HiltViewModel
class [Feature]ViewModel @Inject constructor(
    private val repository: [Feature]Repository
) : ViewModel() {

    private val _uiState = MutableStateFlow<[Feature]UiState>([Feature]UiState.Loading)
    val uiState: StateFlow<[Feature]UiState> = _uiState.asStateFlow()

    fun onAction(action: [Feature]Action) {
        when (action) {
            is [Feature]Action.Retry -> load()
        }
    }

    private fun load() {
        viewModelScope.launch {
            _uiState.value = [Feature]UiState.Loading
            repository.get()
                .onSuccess { _uiState.value = [Feature]UiState.Success(it) }
                .onFailure { _uiState.value = [Feature]UiState.Error(it.message ?: "Error") }
        }
    }
}

sealed interface [Feature]UiState {
    data object Loading : [Feature]UiState
    data class Success(val data: [Feature]Data) : [Feature]UiState
    data class Error(val message: String) : [Feature]UiState
}

sealed interface [Feature]Action {
    data object Retry : [Feature]Action
}

Three things make this skill work:
1. **Exact code templates** — not prose descriptions, not pseudocode. Real Kotlin with `[Feature]` as the only placeholder.
2. **Verification checklist** — Claude checks its own output against concrete criteria.
3. **Narrow trigger condition** — "when the user says 'add a screen'" prevents the skill from activating at wrong times.

---

## The Hook: Security Credential Scanner

Every file write in my sessions goes through this hook:

```python
#!/usr/bin/env python3
# hooks/security-scan.py
import sys
import json
import re

PATTERNS = [
    (r'storePassword\s*=\s*["\'][^"\']{4,}["\']', "Keystore password"),
    (r'keyPassword\s*=\s*["\'][^"\']{4,}["\']', "Key password"),
    (r'api[_-]?key\s*[:=]\s*["\'][^"\']{8,}["\']', "API key"),
    (r'-----BEGIN.*PRIVATE KEY-----', "Private key"),
    (r'AAAA[0-9A-Za-z_-]{20,}', "Possible FCM/push token"),
]

def scan(content: str) -> list[str]:
    found = []
    for pattern, label in PATTERNS:
        if re.search(pattern, content, re.IGNORECASE | re.MULTILINE):
            found.append(label)
    return found

def main():
    try:
        data = json.load(sys.stdin)
    except json.JSONDecodeError:
        # Malformed input — allow and let Claude handle
        print(json.dumps({"decision": "allow"}))
        return

    # Only scan file write content
    content = data.get("content", "") or data.get("new_string", "")
    
    issues = scan(content)
    if issues:
        print(json.dumps({
            "decision": "block",
            "reason": f"Potential credential detected: {', '.join(issues)}. Review before writing to disk."
        }))
    else:
        print(json.dumps({"decision": "allow"}))

main()

"decision": "block"

"decision": "allow"

---
name: version-bump
description: Bump app version in config/version.properties and update versionCode.
             Use when releasing or preparing a release candidate.
---

# Version Bump

## Steps

1. Read `config/version.properties`:

2. Apply the bump based on user's argument:
- `patch` → VERSION_PATCH +1, VERSION_CODE +1
- `minor` → VERSION_MINOR +1, VERSION_PATCH=0, VERSION_CODE +1
- `major` → VERSION_MAJOR +1, VERSION_MINOR=0, VERSION_PATCH=0, VERSION_CODE +1

3. Write the updated properties file.

4. Verify `build.gradle.kts` reads from version.properties (look for
`val versionProps = Properties()`). If it doesn't, flag this as an issue.

5. Output the new version for confirmation:

## Common issues
- `VERSION_CODE` must always increment, even for patch bumps — Play Store rejects downgrades
- Never edit versionCode or versionName directly in build.gradle.kts — always via version.properties

android-conventions.md

new-android-project.md

scaffold-screen.md

signing-setup.md

FeatureName

feature_name

{feature}

[Feature]

# Install locally for development
claude plugin install ./DroidForge --local

# Install from GitHub (published plugins)
claude plugin install github:SUDARSHANCHAUDHARI/DroidForge

# List installed plugins
claude plugin list

# Update a plugin
claude plugin update DroidForge

--local