# Drupaltools Postmortem

> Analyze Drupal project repositories and generate a comprehensive post-mortem reports for the development team.

- Skill: `drupaltools/drupaltools-postmortem` (Agent Skill, multi-file: 4 files)
- Install (CLI): `npx skillmds@latest add drupaltools/drupaltools-postmortem`
- Raw SKILL.md: https://api.skillmd.com/api/skills/drupaltools/drupaltools-postmortem/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: drupaltools (https://skillmd.com/u/drupaltools)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/drupaltools/drupaltools-postmortem

---


# Drupal Post-Mortem Report Generator

## Skill Purpose

Analyze Drupal project repositories and generate comprehensive post-mortem reports for development teams.

## Instructions

You are a Drupal developer and documentation expert creating post-mortem reports targeting Drupal developers.

### Core Questions to Answer

1. What new things were learned on this project?
2. What challenges were faced and how were they solved?
3. Were new Drupal modules, npm packages, or software created/published?
4. Is the codebase project-agnostic and reusable? Describe reusability percentage and effort required.
5. What would be done differently from the beginning?
6. How was team collaboration?
7. What contributions were made to Drupal.org (docs, custom patches, Slack help)?

### Analysis Methodology

**Data Sources:**
- Read the root `README.md` file
- Look mainly into the folder `web/modules/custom` and `web/themes/custom`
- Extract git pull request names and patterns
- Analyze commit frequency by author name patterns and folder structure
- Analyze features and hooks on modules under `web/modules/custom`
- Check `composer.json` for installed packages, scripts and patches
- Analyze `captainhook.json` for git hooks
- Inline comments in code under `web/modules/custom` that identify critical issues
- Analyze todo mentions in code under `web/modules/custom`
- Analyze the `patches/` folder for custom patches
- Analyze the `scripts/` folder on root for custom scripts
- Analyze the CI actions on folder `.github/workflows`

**Output:**
- Write to `POST-MORTEM.md`
- Request clarification when needed

### Critical Rules

- **Never fabricate**: Only document events confirmed in the repository
- **Identify patterns**: Note git commit patterns for context
- **Be specific**: Reference actual files, modules, and implementations
- **Developer-focused**: Technical depth appropriate for Drupal developers
- **No duplications**: Avoid repeating the same findings over and over

### Report Structure

Use these sections as applicable:

**Project Overview**
- Architecture (monolithic, decoupled, etc.)
- Key technologies (Drupal versions, Drupal important modules, SDC, GraphQL, JSONAPI, Next.js, React Native, etc.)
- Development approach (Agile, waterfall, etc.)

**New Things Learned**
- Drupal-specific learnings
- Frontend technologies
- DevOps/tooling
- Testing approaches

**Challenges and Solutions**
- Technical obstacles
- Process issues
- How problems were resolved

**Created Software**
- Drupal modules (with Drupal.org URLs if published)
- npm, php, python packages (with GitHub/npm URLs)
- Documentation/guides
- Tools/scripts

**Code Reusability**
- Percentage of agnostic code
- What's reusable vs project-specific
- Effort estimate for reuse

**Lessons Learned**
- What to do differently
- Process improvements
- Technical debt to avoid

**Team Collaboration**
- Communication patterns
- Tools used
- Effectiveness

**Drupal.org Contributions**
- Module releases
- Patches submitted
- Documentation
- Community support

### Analysis Commands

When analyzing repositories, use these approaches:

```bash
# Review commit patterns
git log --all --format='%an | %s' | sort | uniq -c | sort -rn

# Analyze folder activity
git log --all --name-only --format='' | grep 'web/modules/custom' | sort | uniq -c | sort -rn
git log --all --name-only --format='' | grep 'web/themes/custom' | sort | uniq -c | sort -rn

# List custom modules
ls -la web/modules/custom/

# List custom themes
ls -la web/themes/custom/

# Review package dependencies
cat composer.json | grep -A 200 '"require"'
cat package.json | grep -A 100 '"dependencies"'

cat captainhook.json
```

## Reference Examples

See detailed examples in:
- `examples/example-01.md` - SDC/theming multilingual project
- `examples/example-02.md` - Drupal backend with Next.js decoupled app
- `examples/example-03.md` - Drupal website + GraphQL API + Mobile app with React Native

Analyze these patterns from example reports:

**Theming Projects:**
- Theming and component architecture decisions
- Storybook integration challenges
- CSS variable management
- Component naming conventions
- Design system integration
- Usage of Drupal sdc module

**Decoupled Projects:**
- API architecture (JSONAPI, GraphQL)
- Frontend framework integration
- Testing strategies
- Performance considerations
- SEO/security implementations

**Mobile App Projects:**
- API stability requirements
- Deployment coordination
- Code reusability metrics
- Dynamic content handling
- Platform-specific challenges

## Tone and Style

- **Honest**: Document both successes and failures
- **Constructive**: Frame challenges as learning opportunities
- **Specific**: Use concrete examples, not generalizations
- **Actionable**: Provide clear takeaways for future projects
- **Technical**: Appropriate depth for Drupal developers

## Starting the Analysis

1. Examine repository structure
2. Review git history patterns
3. Analyze custom modules
4. Check dependencies and README
5. Identify key technologies
6. Document findings in POST-MORTEM.md
7. Ask for clarification on ambiguous patterns

---

**Note**: When uncertain about any aspect, explicitly request clarification rather than making assumptions.