Development of an AI system for automatic job description generation

Automatic generation of job descriptions: where the process breaks

A recruiter starts writing a job description from scratch for almost every request: manual writing of descriptions takes hours, and the finished text is then not reused anywhere.

At the same time, across branches there are disparate job templates — each team has its own structure, its own block order, and its own tone.

The same specialist level in two cities is described so differently that a candidate does not understand where the requirements are stricter.

Coordination of texts goes into email threads and files like “final_2_edits” in Google Docs. The department head, lawyer, and marketing edit in turn, and some edits go into publication without a second proofread.

This leads to two expensive classes of failures: errors in candidate requirements — mismatch of tasks and responsibilities, disputed wording, “experience from three years” in a block that no one checked. The candidate is screened out on the first call, and the application is wasted.

Publication delay is made up of small things: a day for the text, two for approval, another day for edits after the first version. During these days, strong candidates already receive offers elsewhere, and the vacancy reaches the market late. Next, we break down how this is closed systematically.

Implementation effect: speed, unified style, fewer edits

Time to a finished draft

Previously, a recruiter gathered input from the hiring manager, pulled up similar descriptions, manually transferred blocks, and coordinated wording — one draft took half a working day, and for an urgent vacancy the work went beyond schedule.

The system assembles the first version from a completed questionnaire: role, level, tasks, experience requirements, conditions.

The draft arrives in minutes, and the time for preparing a description goes not into typing text but into semantic review — the volume of manual work is reduced severalfold.

Unified style and description structure

Tone and format rules are hardcoded into the template, not into the author’s memory: a fixed set of blocks, equal section length, a unified address to the candidate.

Therefore, the share of texts returned for editing after review falls — approvers do not have to argue about wording; they verify facts.

Disputed requirements such as “stress resistance” and “young team” are filtered out at the generation stage, and HR does not manually sort through them.

We measure the effect before and after along four lines: time to a finished draft, share of descriptions accepted without re-editing, completeness of mandatory blocks, number of removed disputed formulations.

For external job boards and recruitment systems, the text is exported into a structure accepted by Huntflow — there is no longer any need to transfer fields and clean up markup manually.

Comparison of approaches: templates, rules, trainable model

The text assembly mode is chosen by hiring volume and requirements for wording control, not by the “advancement” of the method. The template approach maintains structure and mandatory blocks but falls apart on non-standard roles.

Text composition rules are verifiable and predictable, but they do not paraphrase meaning — texts come out dry and similar to each other.

A trainable model removes this dryness, but without a constraining layer it invents requirements the customer did not state. Hence the hybrid mode: rules are responsible for structure, facts, and prohibitions; the model is responsible for wording within the given framework.

In any option, wording control is placed at the output: mandatory items, cutting off prohibited promises, reconciliation with the original vacancy requirements. Edits are made point by point, not by rewriting the whole text.

Implementation stages: from text analysis to handover of the regulation

Implementation begins not with generation but with analyzing what is already published. We export the corpus of current descriptions, find repeated structures in it and places where the recruiter still edits the text manually.

Then we build the chain so that automation covers exactly the routine, while disputed wording remains with the human.

Audit of current texts and solution design

1. Text audit. We analyze a sample of published descriptions across different roles and grades: block structure, length, tone, share of edits after publication. The output is a map of what is generated automatically and what requires approval.
2. Solution design. We fix the composition of blocks (about the company, tasks, requirements, conditions), data sources in internal systems, and points where an employee confirms the result. We agree on fields and rules for filling them.
3. Setting up generation rules. We define structure and style: mandatory items, block order, prohibited evaluative and discriminatory wording, separate templates for grades and departments.

Quality check on historical data

• Check on historical data. We run the rules on texts that were not used during setup and compare the result with what was published before.
• Quality metrics. We calculate the share of descriptions accepted without edits and analyze edits by type: missing requirement, extra block, wrong tone.
• Iterations. We refine rules and examples based on the most frequent errors, repeating the check until a stable result on the control sample.
• Acceptance and training. We hand over the work regulation, instructions for recruiters, and the procedure for handling disputed cases — the customer’s team runs the system independently.

Handover kit: settings, templates, quality policies

The system is handed over not as a black box but as a working kit: after acceptance, job description generation, template edits, and troubleshooting happen within your team, without contacting us for every setting.

The kit is designed for two roles — the recruiter changes the tone and structure of the text, and the supporting engineer is responsible for rules and dictionaries.

Settings, templates, and terminology dictionaries

• System settings with a description of each option: mandatory vacancy fields, required detail level, restrictions on text length and structure.
• Template library for vacancy families — engineering, sales, operations — with notes on which block is responsible for what.
• Dictionary of terms and prohibited wording: unified names of positions, products, and internal systems.
• Text quality policies — criteria for accepting a description and thresholds at which a draft goes to manual review.
• Reference examples: vacancies with benchmark descriptions for checking after edits to templates or the dictionary.

Documentation and work regulations

• Instructions for the team: how to set a task for the system, how to analyze an unsuccessful result, and where to look first.
• Update regulation: who changes templates and rules and in what order, how the version is recorded, and how to roll back.
• Map of connections and access: where the system gets vacancy data from, where it sends the finished text, and which roles are allowed to do this.

Implementation case study: metrics before and after system launch

Situation before implementation

Descriptions were prepared manually by recruiters: each division had its own table, wording did not match, and mandatory blocks — responsibilities, requirements, conditions — appeared inconsistently.

One text took from 3 to 5 hours of work including approval with the manager, and every third vacancy was returned for editing due to incomplete or unaligned text.

Result after launch

The system was built as a service with a unified set of fields: the recruiter fills out a structured profile, generation runs on models deployed in the customer’s environment on Hugging Face — data does not leave the infrastructure.

The draft is produced in about a minute, with another 15-20 minutes for checking facts and tone. Returns for editing decreased from 62% to 14%, and completeness of mandatory blocks increased from 47% to 96% — this is uniformity across divisions in measurable form.

Quality was confirmed by manual labeling: 50 descriptions from different divisions were assessed against a checklist at each setup iteration.

Rolling back to the previous set of instructions and templates takes minutes — if a new version worsens the texts, we return to the previous one without stopping the service.

What to do if the company already has its own text bank?

The first step with any accumulated archive is inventory: texts are labeled by structural blocks (about the company, tasks, requirements, conditions), duplicates and outdated versions are removed, and wording is brought to a unified form.

A heterogeneous array without such preparation pulls contradictions into training: the same section in different texts is written in different words and with different logic, and the system learns both variants as the norm.

Next is a choice among three scenarios. Archive as a training foundation: from pairs of “author’s draft — published text,” rules are extracted — how the product block opens, in what order requirements go, which phrases the company never uses.

Each rule retains a source, so it can be shown to an editor and disputed rather than taken on faith.

Archive as a reference: generation runs on new rules, while accumulated texts remain a base for authors and material for style reconciliation.

A new text is compared with a benchmark block from the archive by structure and vocabulary, and discrepancies are shown to the editor before publication — this is faster and safer than rewriting the entire array at once.

A phased transition relies on template reuse: frequent constructions are moved into blanks, and authors gradually switch to them — first for new vacancies, then for reposts.

Rules are transferred in portions, with style reconciliation on selected pairs of texts after each, so that the benchmark does not diverge from what is actually published.

Which scenario to take is decided by three things: the volume of the archive, its homogeneity, and the share of texts that are still relevant. If half the array is outdated, there is nothing to train on — we start with the reference and a phased transition to new rules.

FAQ: text quality, data, and fine-tuning

Doubts at the contractor selection stage rarely concern generation itself — more often people ask about data, fine-tuning, and who is responsible for the final text.

Below we answer substantively and immediately mark the boundaries that automatic job description generation does not cross.

How does fine-tuning the system maintain text quality?

Before the start, we fix a benchmark — 50–100 descriptions labeled by your editor. Fine-tuning runs on them, and we calculate text quality not “by eye” but by the share of edits: how many sentences the editor rewrites after generation. The target is isolated edits per vacancy instead of manual rewriting from scratch.

Who is responsible for the wording in the finished description?

Responsibility for the text during implementation is ours. Brand rules, prohibited wording, and mandatory blocks — conditions, requirements, application procedure — are hardcoded into the template and validator.

If the generated text violates a rule, it does not go to publication; instead, it enters a review queue with the reason indicated.

Where does the model make mistakes, and how do you work with limitations?

The model does not invent facts: level, schedule, and requirements are taken from the vacancy card. Where there is no data, an explicit gap is placed rather than a plausible phrase — otherwise the description looks convincing but misleads the candidate. For rare roles with narrow terminology, we leave a manual mode with auto-suggestions.

Let's discuss the task: we'll come back with an estimate and implementation plan

To come back with a timeline estimate, scope of work, and first-stage plan, we need not a detailed document but a substantive conversation about your task.

Below is what is useful to prepare in advance: the more precise the inputs, the fewer assumptions in the estimate and the more predictable the first stage.

• Examples of job descriptions you consider benchmarks, and those that must not be edited: they set the tone, structure, and mandatory blocks.
• Vacancy data and reference books: grades, position titles, divisions, cities, work formats — a source for generation and validation.
• Requirements for languages and volume: which languages we write in, whether localization is needed, what text length range is acceptable.
• Restrictions on wording: prohibited phrases, discriminatory turns of phrase, mandatory mentions — what the model has no right to generate.
• Current path: where and how descriptions are created now, who edits them, at which step they are published.
• Access and data handling rules: what can be transferred to external services and what must remain within your environment.

Based on the discussion, we will fix the scope of work, state timelines, and define approval points: text quality, wording safety, and the method of integration with your recruitment system.

Describe the task in a convenient format — we will come back with an estimate and a first-stage plan.