Most architects can describe the feeling. You're deep into RIBA Stage 4, drawings are progressing, and the specification is the thing holding up the package. NBS Chorus works, technically. You can search clauses, build a spec document, and export it. But the workflow hasn't fundamentally changed in years, and the friction points have become harder to ignore as project timelines compress.
The average UK practice spends between 15 and 25 hours writing a specification for a mid-complexity commercial project. That figure hasn't moved much since Chorus launched. The tool digitised the process of finding and assembling clauses, which was a genuine step forward from paper-based systems. But it didn't change how long it takes to think through material selections, coordinate with drawings, or verify that your spec aligns with current regulations.
That gap between "the tool exists" and "the tool actually saves time" is where the frustration sits.
It would be unfair to dismiss Chorus entirely. It built its reputation on a solid foundation: a well-maintained clause library, regular updates tied to British Standards, and a structured approach to specification that brought consistency to an otherwise fragmented process. For many practices, it replaced bespoke Word templates and inconsistent spec documents with something standardised.
The Uniclass integration is useful. The clause library is extensive. And for practices that have invested years building their office master specifications within Chorus, there's genuine institutional knowledge embedded in those templates.
None of that is trivial. But the question architects are asking today isn't "does Chorus work?" It's "does it work well enough given what's now possible?"
One of the most common complaints about NBS Chorus is how rigid the template structure feels. You pick a system, select your clauses, adjust the variables, and export. The process is linear and predictable, which sounds like a good thing until you're working on a project that doesn't fit neatly into the predefined categories.
Adaptive reuse projects are a good example. You're specifying a mix of retention, repair, and new-build elements across the same building. The clause library doesn't always accommodate that overlap cleanly. You end up copying clauses between sections, manually adjusting references, and spending time on formatting rather than on the substance of what you're specifying.
The same issue appears in projects with unusual material palettes or non-standard construction methods. The tool assumes a conventional approach, and deviating from it creates extra work. Architects working on passivhaus projects, mass timber buildings, or heritage restorations know this particularly well.
Over time, these small inefficiencies compound. A senior architect spending an extra two hours per specification adapting Chorus to fit the project is a senior architect not spending those hours on design review or client communication.
Specification doesn't exist in isolation. It needs to align with drawings, schedules, and the broader project documentation. This is where traditional spec tools, Chorus included, create the most pain.
When you update a window schedule in your drawing set, your specification should reflect that change. When Building Regulations Part L requirements shift, your insulation specs need to follow. When the structural engineer changes the concrete mix, the relevant clauses need updating.
In practice, most of this cross-referencing happens manually. An architect reads the updated drawing, opens the spec, finds the relevant clause, and makes the edit. Multiply that across dozens of specification sections and hundreds of potential coordination points, and you have a workflow that's genuinely prone to error.
The consequences aren't abstract. A misaligned specification can lead to incorrect materials being ordered, disputes during construction, and in serious cases, non-compliance with building regulations. These are the kinds of mistakes that cost firms money and reputation, and they almost always trace back to a coordination gap rather than a lack of technical knowledge.
AI-powered specification tools approach the problem differently. Rather than starting with a static clause library and asking you to assemble it, they start with your project information and generate a draft specification that reflects your specific context.
The practical difference is significant. Instead of searching through hundreds of clauses to find the right ones, you describe your project requirements, materials, and performance criteria. The AI produces a first draft that you then review and refine. The time spent assembling drops dramatically. The time spent reviewing and exercising professional judgement stays the same, which is exactly how it should be.
Avoice is one example of this approach in practice. It ingests a firm's existing project documentation, sheets, schedules, material libraries, and historical specifications, then uses AI agents to generate Uniclass-classified or CAWS-classified specs that cite the right standards, products, and clauses. Rather than building from a generic clause library, it draws on your firm's own data and the specific project context to produce a first draft that's already tailored to what you're working on.
Cross-referencing benefits too. Because a platform like Avoice holds your project data in a single intelligent environment, it can flag inconsistencies between your spec and your schedules before they become problems on site. That's not a theoretical capability. It's the kind of check that currently relies on a diligent architect catching a discrepancy during a final review, often under time pressure.
The shift toward AI specification writing doesn't mean architects stop thinking about specifications. Quite the opposite. It means they spend more time on the decisions that require experience and less on the mechanical work of document assembly.
Material selection still requires professional judgement. Understanding the specific conditions of a site, the preferences of a client, and the practical realities of a contractor's supply chain isn't something an AI can do from a brief alone. Fire rating decisions for complex building geometries, acoustic performance requirements for mixed-use schemes, and durability considerations for coastal buildings all need an architect's eye.
The best AI specification tools recognise this boundary. Avoice's approach, for instance, is to produce a strong first draft using your firm's institutional knowledge and then get out of the way, letting the architect focus on the 20% of the specification that requires genuine expertise rather than the 80% that's assembly work.
This distinction matters because it addresses the concern many architects have about AI: that it will produce generic or incorrect specifications. A well-designed tool doesn't try to replace the architect. It gives them a better starting point, grounded in the standards and product data relevant to the project.
The move away from traditional specification tools isn't a prediction. It's something you can see in how practices are allocating their time and budgets. Firms that previously accepted 20-hour specification cycles as inevitable are discovering they can produce a solid first draft in a fraction of that time. The hours saved go back into design quality, client relationships, and the parts of practice that architects actually enjoy.
For practices still weighing their options, the decision isn't really about choosing one tool over another. It's about whether the current approach to specification writing is sustainable as projects get more complex, timelines get tighter, and the cost of coordination errors keeps rising.
NBS Chorus served the industry well for a long time. But the assumptions it was built on, that specification is primarily a search-and-assemble task done by a single person working through a clause library, are increasingly at odds with how modern practices operate. AI-powered alternatives like Avoice don't just speed up the old process. They rethink what the process should look like when you remove the constraint of manual assembly and give the AI access to your firm's accumulated project knowledge.
The practices making the switch aren't doing so because they're early adopters or technology enthusiasts. They're doing it because the numbers make sense and the output quality holds up. That's a practical decision, not a trendy one, and it's the kind of shift that tends to stick.
