My approach is pretty informal. I'm currently writing a Slash plugin for an article to plug an upcoming book. After coming up with the idea (an entirely new subject in itself), I did a little design.

Most of that design is breaking the problem into tasks. Each task is supposed to be a standalone piece of functionality that can be accomplished in under two hours. This is a brainstorming session, where I figure out what's really necessary and often come up with useful enhancements. I rarely put the enhancements in, the first time. I end up with a small text file similar to:

- display a page
    - current version
        - no arguments
        - op=display
        - ver=version number
    - list of previous versions
        - author
        - changes ?
        - links
    - restore previous version
        - only for administrators
        - delete everything later ?
    
- edit a page
    - allow wiki markup
        - save rendered version
    - save previous versions
- access control
    - restrict based on seclev
    - optional restriction based on user flag
- index
    - list pages
    - search pages
    - recent changes
- markup parser

Schema
------

- wikipage
    - user (uid)
    - title (name of page)
    - date (change date)
    - version (autoinc)
    - description (char 255)
    - wid (wikitextid)

- wikitext
    - wid (wikitextid)
    - text
    - rendered
    - version
[download]

They're arranged in *rough* order of importance. Each indentation level allows further detail. I don't keep many design notes at this stage, but occasionally I'll think of something that may work.

Then I go on to coding. I usually write tests before code. This time, I was revising an existing bit of code, and wrote the tests later. That made for more debugging time and brought shame to my ancestors.

I have the display and list bits coded, and the parser is there as well. I've left the database for a bit later, but that's probably next on my list as I put in the edit/save files.

Does this make any sense at all?