Messy lived in a particularly messy-looking house. The paint was peeling—just like his PHP code, full of syntax errors and no linting to catch them. The windows were broken—like his Fusion templates, unpredictable and nearly impossible to debug. There were tiles missing from the roof—much like the nodetype inconsistencies in his project, where some pages loaded fine, and others failed completely at random. The flower beds were overrun with weeds, and the garden gate hung off its hinges—a perfect metaphor for his lack of testing, where every fix introduced more bugs than it solved. And had Mr. Messy cut the grass lately? He had not!
rolled out of his messy bed, yawned, scratched, and shuffled into the chaos of his usual routine. He brushed his teeth—leaving the cap off the toothpaste, just like he'd been leaving syntax errors all over his messy PHP code. At breakfast, he poured himself a bowl of cereal—cornflakes flew everywhere, much like his Fusion templates, scattering unpredictable errors with every render. Heading out the door, he tripped over a broom he’d left lying in the yard two weeks ago. That broom? Technical debt—ignored and waiting to strike at the worst possible moment. But Mr. Messy wasn’t just stumbling through his morning— It was Launch Day.
for a stroll and found the neatest, prettiest-looking little cottage he had ever seen. It had a lovely yard with a stream running right through the middle—a smooth CI/CD pipeline, perhaps? There was a man in the yard, clipping the hedge with precision. As Mr. Messy approached, he said, “Good morning! I’m Mr. Messy!” The man looked him up and down and replied, “I can see that. I’m Mr. Tidy.” Then another man appeared from the house, holding a clipboard and a lint report, “And I’m Mr. Neat.” “Tidy and Neat,” said Mr. Tidy. “Neat and Tidy,” said Mr. Neat. Together, they were everything Mr. Messy wasn’t—order, clarity, and care.
explained Mr. Tidy. “And the people who own this house asked us to do some work.” “What sort of work?” asked Mr. Messy. “Oh, we make things nice and neat,” said Mr. Neat, flicking a speck of dust off his PHPStan manual. “Tidy things up,” added Mr. Tidy, holding a folder labeled CI/CD Pipelines – Jenkins. “Perhaps we could come along and do some work for you?” Mr. Neat offered, eyeing Mr. Messy, who looked even more unstructured and untested than usual that morning. “But I don’t want things neat and tidy,” muttered Mr. Messy, looking downright miserable at the thought of it. The very idea of linting Fusion files, YAML schema validation, unit tests, and automated pipelines made him twitch.
pulling on his Jenkins gloves. “Fiddlesticks!” said Mr. Neat, tucking a PHPUnit test report into his toolbelt. “But…” Mr. Messy tried to argue. “Come along,” said Mr. Neat, pulling out a USB stick labeled Playwright E2E tests. “Off we go,” said Mr. Tidy, opening the doors to their code-cleaning van, humming with Fusion.Tracing dashboards. “But… but…” Mr. Messy stammered. “But nothing,” said Mr. Neat. Before Mr. Messy could even write another untested function, they’d bundled him into the van and were off— Heading straight to his project at the other side of the wood.
Neat when they arrived. “Good gracious me,” added Mr. Tidy. “This is the messiest house—er, codebase—I’ve ever seen in all my born days,” they both said at the same time. There were inline scripts tangled like weeds, Fusion templates with zero linting, and YAML files yelling in syntax agony. “Better do something about it,” said Mr. Neat, already unpacking the Neos Code Styles formatter. Before Mr. Messy could even open his mouth, they were rushing here and there— running PHPStan, validating schemas, snapshotting layouts, and setting up the first Jenkins job he’d ever seen.
hoed through outdated YAML configs, mowed down wild, overgrown Fusion structures, and pruned unnecessary HTML wrappers. He clipped duplicated PHP functions and old, forgotten classnames. He cleared performance bottlenecks using Fusion.Tracing and Neos.Debug, and dug deep into layout rendering with Snapshot testing. He set up functional and unit tests with PHPUnit and Fixtures, then handed the clean code pipeline over to Jenkins with a satisfied smile. By the time he was done, the yard—er, frontend—looked better than ever: Fast, clean, and stable.
cleaned up the controllers, scrubbing away years of tangled logic. He rubbed through every config file, aligning them with YAML schema validation. He primed and mended broken endpoints, added type safety checks with PHPStan, and enforced Neos Code Styles for clarity. Then he painted the codebase with clean comments, refactored classes, and beautifully structured modules. By the time he was done, the outside of Mr. Messy’s codebase—the foundation, the APIs, the data flow—looked more solid, consistent, and maintainable than it ever had before. Mr. Messy peeked out and blinked. He barely recognized his own backend.
stepped into the house. “Good heavens!” said Mr. Neat—for the second time that morning. “Good gracious!” echoed Mr. Tidy—also for the second time. And without another word, they set about cleaning the house from top to bottom. They brushed through templates using Fusion Linting. They swept away duplicate and unreachable code. They polished the UI with Snapshot validation and Playwright E2E tests. They scrubbed business logic and added PHPUnit functional tests. They even optimized performance with Fusion.Tracing. And wired it all together in a neat, reliable CI/CD pipeline with Jenkins. By the time they were done, the inside of Mr. Messy’s house—his codebase—looked neater, faster, and more maintainable than it had ever looked before.
Tidy, wiping Jenkins dust from his gloves. “All finished,” said Mr. Neat, closing his laptop with the last successful test run glowing green. “Tidy and neat,” smiled Mr. Tidy, gesturing at the polished codebase.' “Neat and tidy,” nodded Mr. Neat, admiring the structured, fast-loading site. • The garden was green, the house was pristine, and the codebase? Clean, fast, and predictable. • The code was linted and formatted. • Tests were all passing—unit, functional, and E2E. • The CI/CD pipeline was running smoothly. • Performance metrics were clean and optimized. • Pages loaded in milliseconds. Mr. Messy looked around—at the stable site, the readable code, the clean structure— and for once in his messy life… he just didn’t know what to say.
1 | ERROR | Presentation prototype is "Neos.Neos:ContentCollection" but has to inherit from one of: Neos.Fusion:Component prototype(Site.BaseComponents:Button) < prototype(Neos.Neos:ContentCollection) { renderer = afx`<button class="primary">{props.label}</button>` }
and settings configs Prevents: • Invalid childNodes, broken help messages, rendering bugs Why it’s good: • Ensures structure is predictable • Makes editor UI work as intended 🔖 https://github.com/Sebobo/Shel.Neos.Schema
— like logging into the CMS, creating content, and verifying it's live Prevents: • Critical workflows breaking after deployment • UI inconsistencies across browsers or environments Why it’s good: • Catches regressions before your users do • Tests full flow: login → content → publish → frontend • Validates things unit & functional tests can’t reach 🔖 https://gauge.org/index.html
a new blog article * Call the URL "https://cms.cloud.io/neos/" async function createAndPublishBlogArticle(url) { let page = await openBrowser(); // Login to the CMS // Go to the blog section // Create a new blog article // Fill in the article details // Publish the article // Call Website with new blog article } 🔖 https://gauge.org/index.html
didn’t know what to say. The project was clean. The site was fast. The logs were quiet. Then Mr. Neat and Mr. Tidy turned to look at him. “Are you thinking what I’m thinking?” Mr. Neat asked, adjusting his Fusion code linter. “Precisely,” replied Mr. Tidy, glancing at his PHPStan rule set. Then they both turned to Mr. Messy. “What we’re both thinking,” they said together, “is that you look much too messy to live in a neat and tidy codebase like this!” Mr. Messy’s eyes widened. “But…,” he said, clutching his old habits, “…what about my quick fixes? My random commits? My late-night hotpatches?!”
Mr. Messy said was no use. Mr. Neat and Mr. Tidy whisked him off to the bathroom upstairs once the messiest room in the house, now spotless thanks to clean configs and automated tests. Then Mr. Neat grabbed one arm (still holding a manual deploy script), and Mr. Tidy grabbed the other (clutching a stack of unchecked TODOs), and they dropped him straight into the bath. In went the linters, out came the unit tests, followed by a good scrub of CI/CD best practices. Mr. Messy wasn’t used to baths… …or to writing clean, testable code.
Mr. Tidy washed and brushed, cleaned and scrubbed, combed and linted until Mr. Messy didn’t look messy at all. In fact—he looked the opposite of messy. His code was clear. His commits were clean. His tests were green. He stared at himself in the mirror, eyes wide. “You know what I’m going to have to do now?” he said in a rather fierce voice. Mr. Neat and Mr. Tidy froze. Had they pushed him too far? Was he about to revert to main without review?
"What are you going to have to do?" they asked Mr. Messy. "I'm going to have to change my name!" said Mr. Messy. And then he chuckled. And Mr. Neat and Mr. Tidy chuckled. And then Mr. Messy laughed. And Mr. Neat and Mr. Tidy laughed. And then they all laughed together and became the best of friends. And that really is the end of the story, except to say that if you're a messy sort of person, you might just get a visit from two people— Mr. Neat and Mr. Tidy, who’ll help you clean up your code and your workflow.
bitkey
tokuty
nttcom
satoshi7
ymotongpoo
mohab1
prog893
riyaamemiya
puhitaku
nealle
ivry_presentationmaterials
.png){kind=avatar}
codatum
greggifford
sergeychernyshev
elsirapls
notwaldorf
csswizardry
destraynor
bluesmoon
nwiizo
marcduiker
bryan
marcelosomers
mfonobong
