Songwriting structure templates: six forms, six jobs

Structure is the one field a rerun does not fix

Almost everything in a generated song is repairable. Thin mix: run it again. Dead line in the second verse: rewrite six words, paste it back, done. Wrong voice, wrong style tag, wrong tempo feel, all of that is one more generation away.

Structure sits outside that repair loop. It is not a sound. It is a schedule for the listener's attention, and it hardens the moment the lyric leaves your hands. Put the first chorus at 1:38 of a 2:10 track and the song is already lost, because most people decide somewhere around 0:30 whether they are staying. Regenerating gives you a better-sounding version of the same mistake.

This is the reason the song generator on sunomarket treats structure as a required field rather than something a model quietly invents. Six named forms, six different jobs, and picking the wrong one costs you the listener rather than the audio quality.

The six structures, and what each one buys

Classic: verse, chorus, verse, chorus, bridge, chorus

The workhorse. Two full chorus landings before the bridge, so somebody who gives you ninety seconds still hears the hook twice. The bridge then buys a lift: new chords, new angle, often a new addressee, and the last chorus lands on ears that missed it for forty seconds.

What it costs: predictability, and a second verse that has to earn its place. If verse two restates verse one in different words, the song sags exactly where it should be gathering speed. Change the time, the place, or who is being spoken to.

Where you hear it: mainstream radio pop, almost every rock single of the last fifty years, anything written so a room can sing it back at you.

[Verse 1]
[Chorus]        <- hook lands here, target 0:30-0:40
[Verse 2]
[Chorus]        <- identical words, second landing
[Bridge]
[Chorus]        <- final landing, often the strongest delivery
[Outro]

No-bridge: verse, chorus, verse, chorus, chorus

Strip the bridge and you buy time. Two and a half minutes, no dead air, the hook back every forty seconds. Punk lives here. So does most club-facing dance music, most TV edits, and any track meant to be over before the listener reaches for the skip.

What it costs: relief. Without a bridge the third chorus can start to nag, because nothing has changed the frame. Compensate in the arrangement, not the lyric: drop the low end under the final chorus, or let the last pass start bare.

Where you hear it: fast punk, garage, edits made for a dancefloor where a bridge kills the momentum.

[Verse 1]
[Chorus]
[Verse 2]
[Chorus]
[Chorus]        <- straight repeat, no bridge, out

Double-chorus: the hook twice in a row

The chorus fires back to back, usually at the end, sometimes after every verse. Repetition is the whole product here. A listener who half-heard the hook gets a second free pass at it with no gap to forget in.

What it costs: the hook has to be good enough to survive immediate repetition. A mediocre chorus doubled is not twice as memorable, it is twice as irritating, and you find out four seconds too late. Write the hook first, test it against the rules that make a chorus land, then decide whether it deserves doubling.

Where you hear it: stadium anthems, festival EDM where the second pass is the drop, gospel-shaped call and response.

[Verse 1]
[Chorus]
[Chorus]        <- immediate repeat
[Verse 2]
[Chorus]
[Chorus]
[Outro]

Story: through-composed, no repeating chorus

Nothing comes back. Each section moves the plot, and the payoff is the ending rather than a hook. Done well it is the only structure that makes someone sit through four minutes to find out what happened.

What it costs: everything the other five buy. No singalong, no hook, nothing for a fifteen-second clip. It also fights short generation lengths harder than any other form, which is covered below.

Where you hear it: murder ballads, folk narrative songs, narrative country, rap records where each verse advances a timeline instead of restating a mood.

[Verse 1]
[Verse 2]
[Verse 3]
[Bridge]        <- the turn: the thing the listener did not see coming
[Verse 4]       <- consequence, resolution, the last image

Loop: hook-driven, minimal verse

Hook first, tiny verse, hook again. The listener knows what the song is within eight seconds, which is exactly what short-form video and a dancefloor both want.

What it costs: somewhere to go. A loop is finished the first time you hear it, so it has to be either short or so physically satisfying that repetition is the point. On play four a weak loop is unbearable.

Where you hear it: trap hook records, dance floor tools, game and stream loops, jingles.

[Intro]         <- hook line, bare, no build
[Hook]
[Verse]         <- four lines, no more
[Hook]
[Verse]
[Hook]
[Hook]

Ballad: slow build, one big lift

Verse-led, longer lines, space between phrases, and a single deliberate rise into the final chorus. The form assumes the listener has already agreed to stay, which means it works badly for a cold audience and beautifully for one that came for the song.

What it costs: patience, and an arrangement that grows. Flat dynamics turn a ballad into three minutes of the same thing, and no lyric rescues that.

Where you hear it: piano and acoustic love songs, power ballads, anything built around one voice and a long note.

[Intro]
[Verse 1]
[Pre-Chorus]
[Chorus]        <- restrained, held back on purpose
[Verse 2]
[Pre-Chorus]
[Chorus]
[Bridge]        <- the emotional turn, quietest point
[Chorus]        <- full, the only time everything is present
[Outro]

The tags Suno actually reads, and what happens without them

Section tags go in square brackets on their own line: [Verse], [Chorus], [Bridge]. Those three carry most of the work. [Intro], [Pre-Chorus], [Hook] and [Outro] are also read, and there is a longer list worth knowing in the guide to Suno metatags that hold up.

Leave them out and the lyric arrives as one undifferentiated block. The model still needs a shape, so it invents one, and the shape it reaches for is repetition: it picks whichever lines look most hook-like, sings them at intervals, and gives you an even track with no rise and no landing. This is the flattening people mean when they say the generator ignored their song. It did not ignore anything. It was never told where the boundaries were, and a boundary is the only thing that gives it permission to change.

Numbering the repeats helps too. [Verse 1] and [Verse 2] read as different sections; two bare [Verse] tags sometimes get treated as the same one, which is a fast way to lose a verse.

Everything outside the brackets gets sung

This one costs people a whole generation. The Lyrics field is not a document with notes in it. Every character that is not inside square brackets is treated as words to be sung, so a line like

guitar solo here, then quiet

comes back as a vocal singing the phrase "guitar solo here, then quiet", usually with real conviction. Same for "chorus x2", "(spoken)", "instrumental break", and the stage directions people carry over from a lyric sheet.

Put the instruction inside brackets instead, and stack the modifiers with pipes:

[Guitar Solo | no vocals | 8 bars]
[Outro | fade out | instrumental]

The bracket is the entire mechanism. Inside, an instruction. Outside, a vocal. There is no third category, and the walkthrough of writing and editing lyrics in Suno has more on where that line moves.

Timing, honestly

Rough runtimes when the sections are the usual length, four to eight lines a verse:

• loop: 1:30 to 2:20
• no-bridge: 2:00 to 2:40
• classic: 3:00 to 3:40
• double-chorus: 3:15 to 4:00
• ballad: 3:30 to 4:30
• story: 3:30 to 5:00 and often longer

Story structure is the one that fights a short generation. Every other form survives being cut off, because the hook has already landed twice and losing the outro costs nothing. A story song that stops before the last verse has no payoff at all; you have delivered a setup and thrown away the ending. If you cannot control total length, either write the story in four verses instead of six, or pick a different structure, or read up on how to control full song length before you commit a five-minute narrative to a two-minute container.

The practical rule: budget roughly forty to fifty-five sung lines for a three-minute track. Count them before you generate. It takes twenty seconds and it is the cheapest check available, given a song costs 20 credits, about $0.20 at the current rate, and you should confirm the number on the pricing page rather than trusting a figure in an article.

When it goes wrong

The bridge disappears. Almost always a length problem. A two-line bridge sitting between eight-line verses reads as the tail of verse two, so it gets absorbed. Give it four to six lines, change the imagery completely, and if possible change who is being addressed. A bridge that reuses verse vocabulary is a verse wearing a different tag.

The chorus arrives too late. Count the lines in verse one. Twelve lines is roughly fifty seconds of singing, and the hook is now past the point where anyone is still deciding. Cut verse one to six or eight lines. If the song genuinely needs a long opening, put the hook line alone in an [Intro] first so the listener hears it at 0:08 and recognises it later.

The track fades before the last chorus. Your lyric is longer than the container. Trim verse two first, then the second pre-chorus, then the bridge. Never trim the final chorus to make room; that is the section every other line in the song exists to set up.

Every section sounds identical. Two causes. Either the tags are missing, or all the sections are the same length and the same rhythm, so there is nothing to distinguish. Make the chorus lines shorter and blunter than the verse lines. Contrast in line length does more for perceived structure than any tag.

The generator writes a chorus you did not ask for in a story song. It is pattern-matching to the most common shape. Keep the sections labelled [Verse 1] through [Verse 4], use no [Chorus] tag anywhere, and make sure no line repeats verbatim, because a repeated line is read as a hook.

FAQ

Do I have to use tags, or can I just paste the words? You can paste plain words and you will get a song. You will also get whatever structure the model infers, which is usually a loop. Tags take fifteen seconds and are the difference between a shape you chose and a shape that happened.

Can I mix two of these structures? Yes, and the useful mixes are small. A classic with a doubled last chorus is a real form. A ballad with a no-bridge second half works. What does not work is switching frames halfway, for example a story that suddenly grows a repeating chorus in the last minute, because the listener has already stopped waiting for one.

Does the order of tags matter more than the tag names? Order matters more. [Hook] and [Chorus] behave similarly; a [Bridge] placed second in a six-section song behaves nothing like a bridge. Get the sequence right first.

Which structure for a sixty-second video clip? Loop, and it is not close. Hook at 0:00, one short verse, hook again. Classic wastes forty of your sixty seconds on setup.

Does the structure field change the words, or only the layout? Both. Asking for story produces a different lyric, not the same lyric re-tagged: the lines carry plot instead of restating a feeling, and nothing is written to repeat. Same for loop, where the writing gets deliberately blunter because a line you will hear six times cannot be complicated. If you want to feel the difference, run the same theme through the lyrics tool twice with only the structure changed and read them side by side.