How to Build a Self-Improving AI Employee With Jev + Viktor
文章目录
i'm going to show you how to build an AI employee you can hand a goal to, have him figure out the work required, execute across different tools, then evaluate his own output against your criteria and refine it without you prompting every revision.
the assignments, the tools, the review loop, and how to connect everything.
the result is a system that works less like a chatbot waiting for instructions and more like an employee that can take ownership of a piece of work and carry it through on his own.
because getting AI to produce a first draft is easy.
the part that still eats your day is checking it, explaining what’s wrong, and asking him to try again.
here’s what’s inside:
-> give your employee his first assignment -> show him what finished work looks like -> connect Jev to evaluate what he produces -> turn failed checks into another round of improvements -> apply the loop to finding ideas, analysing content and writing drafts -> test the setup and put the useful jobs on a schedule
the mistake: you’re still running the revision loop
you ask AI to write an article about a new AI tool.
the draft explains the features, repeats the launch announcement and opens with something about “the rapidly evolving landscape.”
it never tells the reader what they could actually do with the tool.
so you explain the problems. wait for another version. open it. check again.
then you notice it has turned a proposed workflow into something you supposedly tested yourself.
another correction. another draft.
every revision depends on you noticing something and writing another message.
the setup we’re building moves some of that checking into the workflow.
you define what the assignment needs to accomplish before it starts. the employee plans the work, produces a draft and evaluates it against those criteria. failed checks trigger a revision. missing information and unresolved questions come back to you.
create -> evaluate -> revise -> evaluate again
there’s a limit on revision rounds, and passing the checks still doesn’t guarantee a perfect result. but it gives us a way to catch specific problems before they become another conversation you have to manage.
the setup: an employee and a reviewer
there are two roles to connect.
one needs to read your files, research the topic, use your tools and produce the deliverable.
the other needs to evaluate specific parts of that deliverable and return judgments the workflow can act on.
we’ll use Viktor for execution and Jev for evaluation.
start with the employee.
Viktor executes the assignment, while Jev evaluates the draft and routes the result.
1. give your employee a place to work
Viktor lives inside Slack or Microsoft Teams. he connects to your tools and has his own cloud computer where he can run code and produce files.
that gives us somewhere to put the execution side of the system.
start by adding him to your workspace and connecting the tools your first assignment needs.
for this example, give him access to a folder containing your published articles, research notes, writing examples and content analytics.
then create a channel for the work, invite Viktor and give him a standing brief:
You help me create content about AI, content creation,
growth, marketing and technology.
I write for people who want practical ways to use AI
in their work and businesses, including creators,
marketers and founders.
Help me find strong ideas, research them and turn them
into useful X articles and posts.
Lead with what the reader can achieve.
Explain the tools through concrete applications.
Use the folder I connect for published work, research,
writing examples and analytics.
Keep drafts in a separate review folder.
Write in my lowercase, direct style.
Use plain language, specific examples and short paragraphs.
Avoid generic AI introductions and inflated claims.
Keep source references in research notes.
Do not put external URLs in publication drafts.
Use -> for arrow bullets.
Never invent personal experience, test results,
revenue figures or product capabilities.
When I give you a goal, work out the steps and use the
connected tools to complete them.
You can research, prepare drafts and revise them.
Ask me before publishing, contacting anyone or spending money.
this gives the employee context about the work, the reader and the standards he needs to follow.
next, give him something specific to finish.
giving Viktor the context, voice and boundaries for the work.
2. start with one article you would actually publish
let’s make the first assignment a long-form X article about using AI to turn one original piece of content into a week of useful posts.
it fits the topics i cover, gives readers a concrete outcome and creates several things we can evaluate.
the goal is to help a reader build the workflow, with enough detail to try it themselves.
give Viktor your notes, a few published articles and this brief:
Create a long-form X article showing creators and marketers
how to turn one original article, video transcript or voice
note into a week of distinct, useful content with AI.
Use my supplied material as the foundation.
Read my published examples to understand my voice.
Work out the research, structure and drafting steps.
Deliver:
- 5 headline options built around the reader's outcome
- a complete article draft
- copyable instructions for the workflow
- an example showing how one source produces 5 distinct posts
- separate research notes with supporting sources
- a list of steps that still need a real-world test
Open with a clear promise to the reader.
Explain the problem before introducing the tools.
Each example post must develop a different idea
from the source material.
Preserve the source's meaning.
Do not invent results or imply I tested an untested workflow.
Use lowercase prose, plain language and -> for arrow bullets.
Keep external URLs out of the publication draft.
First propose a short plan and review checklist.
Once approved, complete the assignment within that scope.
Return everything for review. Do not publish.
now the employee has a goal, inputs and a finish line.
he can research the relevant capabilities, identify ideas in the source material, structure the article and produce the example batch.
the next step is deciding how that work will be checked.
3. turn your usual edits into a checklist
think about the corrections you keep making to AI-written content.
“the opening doesn’t give the reader a reason to care.”
“this is a feature list. show what someone can do with it.”
“these five posts are the same idea with different hooks.”
“i never said i tested this.”
those are the beginnings of your evaluation criteria.
for this assignment:
-> the opening names a concrete outcome for the reader -> the article explains the problem before introducing tools -> the workflow includes inputs, instructions and expected outputs -> each example post develops a distinct idea -> factual claims have support in the research notes -> proposed steps are distinguishable from tested results -> first-person claims are supported by my supplied notes -> the draft follows my formatting and writing preferences
some checks are mechanical.
code can count the headline options, detect external URLs and find the arrow character i asked Viktor not to use.
Jev can evaluate focused content questions, such as whether the opening promises a concrete outcome or whether two example posts repeat the same point.
i still decide whether the idea is interesting enough to publish.
give Viktor this instruction:
Build a review checklist for this content-repurposing article.
Include separate checks for:
- a concrete reader outcome in the opening
- the problem appearing before the tool introduction
- usable instructions for each workflow step
- distinct ideas across the 5 example posts
- factual claims supported by the research notes
- first-person claims supported by my supplied material
- clear labeling of untested steps
- my formatting preferences
For each check, record:
- requirement ID
- article section or post being checked
- evidence needed
- code, Jev or human review
Use code for counts, URLs and formatting checks.
Use Jev for focused judgments about the content.
Leave the final editorial decision to me.
Show me the checklist before drafting.
Once approved, keep it fixed during revisions.
now the reviewer is checking the things that actually create editing work for me.
4. give Jev the right questions
Jev takes information and returns structured judgments: a choice, a score, or a yes/no probability.
keep each question focused.
“is this a good article?” bundles together the idea, evidence, writing, usefulness and taste.
instead, start with the opening.
does it tell creators or marketers what they will be able to do after reading?
then check the examples.
do post one and post two develop different points, or do they repeat the same claim using different wording?
then check a first-person statement.
does my supplied material support the claim that i personally tested this workflow?
each question maps to a specific part of the draft and a specific reason to revise it.
Requirement:
The opening must name a concrete outcome for the reader.
Draft opening:
"AI is changing how creators work.
There are more tools than ever, and keeping up is difficult."
Question:
Does this opening tell creators or marketers what
specific result the article will help them achieve?
Possible answers:
- meets_requirement
- fails_requirement
- insufficient_evidence
the expected result is fails_requirement. it describes a topic without making a useful promise.
compare it with:
"i'm going to show you how to turn one original article
into five distinct posts, with a repeatable AI workflow
and the instructions to build it."
that opening states an outcome.
it still needs an article that delivers on the promise. that is a separate check.
5. connect Jev to your employee
you need a TypeSafe API key and a custom API connection in Viktor.
first, open the TypeSafe console. once your account has API access, get your key from the dashboard.
then open a private conversation with Viktor:
Connect TypeSafe's Jev API as a custom integration.
I want to evaluate content drafts against my editorial
checklist and use failed checks to trigger revisions.
Use TypeSafe's current API documentation.
Ask me to add the API key through the integration's
credential setup.
Viktor supports custom API connections. add the key through the Integrations screen when prompted. keep it out of task briefs and generated files.
Viktor sets up the connector and confirms authentication works after i add the key. the evaluation test comes next.
then test the two openings from the previous section and save the working check:
Use the actual Jev API to evaluate both sample openings
against the concrete-reader-outcome requirement.
Use a Choice question with:
- meets_requirement
- fails_requirement
- insufficient_evidence
Show the real responses, including probabilities
and confidence. Do not simulate them.
If the calls work, save a reusable evaluation step
that accepts a requirement, relevant evidence and draft text.
For each result, preserve:
- requirement ID
- section ID
- Jev's answer
- probabilities and confidence
If a call fails, return "not evaluated".
Then evaluate our article against the approved checklist.
Show me the first review before enabling revisions.
the first opening should fail and the second should pass.
inspect the actual results. then review whether the checks on the full article are useful enough to drive revisions.
Viktor reports the Jev API results and flags uncertain judgments for review. a “meets” answer is not a guarantee of correctness.
6. make the result trigger the next action
the workflow needs three routes:
passes the checks -> bring the draft to you
fails a fixable requirement -> revise the affected section
missing evidence or uncertain result -> ask for your judgment
the exact thresholds need testing on your own examples. confidence helps route the result; it doesn’t prove the judgment is correct.
give Viktor the revision rule:
When a requirement fails, revise the affected section
using the original brief and supplied evidence.
Keep the approved checklist unchanged.
Preserve the meaning of the source material.
Do not invent examples, results or personal experience
to make the draft pass.
Run the checks again after each revision.
Allow at most two revision rounds.
Then return the latest draft and unresolved issues.
If evidence is missing or the evaluation is uncertain,
flag it for me.
If a check fails to run, mark it "not evaluated".
here’s how that could play out in our content example:
the article promises five distinct posts from one source.
the first batch contains three posts making the same argument: AI saves time repurposing content. the hooks are different, but the point is identical.
Jev flags the overlapping ideas.
Viktor returns to the source material and looks for other supported points: how to choose the original piece, how to preserve its meaning, or how to adapt it for a different format.
he rewrites the overlapping posts and submits the batch again.
if the source only contains enough substance for three useful posts, he should tell you. filling the remaining slots with invented insights would defeat the point.
7. give him work from the rest of your content process
once the article loop works, reuse the structure for the work around it.
find the next AI article worth writing
the assignment is to find a development that creates a useful story for my audience.
Research recent developments in AI tools, content creation,
growth, marketing and technology.
Find 5 potential X article ideas for my audience.
For each idea, include:
- what changed
- the practical reader outcome
- why it matters now
- the original angle we could contribute
- primary-source evidence
- what we would need to test before writing
Compare the ideas with my published articles.
Flag repeated angles.
Recommend one idea and explain the tradeoff.
Keep source references in separate research notes.
Jev can check whether the proposed angle names a concrete application, whether the supplied evidence supports the claimed change, or whether the idea substantially repeats a previous article.
it can help screen for those properties.
i still choose which idea has enough tension, usefulness or surprise to pursue.
work out what my content analytics actually show
give him an analytics export and the corresponding posts.
Analyse my latest X analytics export alongside the
corresponding posts and articles.
Compare performance across:
- topics
- headline approaches
- formats
- practical tutorials versus commentary
Calculate engagement rates where the export supports them.
Include bookmarks per 1,000 views if bookmarks are available.
Show sample sizes and flag missing metrics.
Separate observations from possible explanations.
Recommend 3 content experiments for the next month.
For each, state what result would support or weaken the idea.
Return a short report and the supporting calculations.
code calculates the metrics.
Jev can assess whether a written conclusion accurately describes the supplied results, whether the report acknowledges a small sample, or whether it turns a correlation into a causal claim.
“the last two tutorials received more bookmarks per view” is an observation.
“tutorials always outperform commentary because my audience prefers education” goes much further than that evidence supports.
turn one approved article into supporting posts
once the article is approved, give the employee a new assignment:
Turn my approved article into 5 supporting X posts:
1. a launch post built around the reader's payoff
2. a standalone practical tip
3. a common mistake explained with an example
4. a surprising implication supported by the article
5. a discussion question grounded in its argument
Each post must stand on its own and develop a different point.
Use my lowercase, direct writing style.
Preserve the article's claims and qualifications.
Do not add results, capabilities or experiences.
Evaluate the batch for repeated ideas and unsupported claims.
Return drafts for review. Do not publish.
Jev checks for overlap between posts and support for their claims.
i decide whether the hooks are strong, whether the writing sounds like me and which posts deserve to go out.
8. test the loop against edits i would actually make
before scheduling anything, build a small review set from my own content.
take an approved draft and create a few deliberately flawed copies:
-> replace the opening promise with a generic AI introduction -> duplicate one post’s argument under a different hook -> insert a statistic that doesn’t appear in the source material -> change “a workflow to test” into “a workflow i tested” -> remove a necessary input from a copyable instruction
keep the approved version too. the reviewer needs to recognise acceptable work as well as mistakes.
then inspect the results.
did Jev catch the unsupported statistic?
did it notice the invented personal experience?
did it reject a useful opening just because it was phrased differently from the example?
next, inspect Viktor’s revisions. did they fix the actual issue while preserving the argument?
run a few assignments with Viktor alone and compare:
-> time i spend reviewing and editing -> unsupported claims left in the final draft -> repeated ideas left in a batch -> useful drafts i would actually publish -> total time and cost
the review loop should reduce the editing burden.
if it produces more activity without better drafts, tighten the questions before adding more assignments.
make each correction useful next time
the revision loop improves the current draft.
for future assignments to benefit, save the lessons somewhere the employee reads before starting.
keep a short working guide alongside your content:
-> published examples that represent your voice -> approved openings and why they work -> rejected angles and why they were weak -> recurring corrections -> factual boundaries and claims that require evidence
when you make an edit, ask Viktor to propose the reusable lesson:
Review my corrections to this article.
Identify lessons that should apply to future content.
Separate general rules from changes specific to this piece.
Propose updates to our working guide for approval.
Include an example showing when each rule applies.
Do not change the current evaluation checklist mid-run.
“use this headline” applies to one article.
“open practical guides with a concrete reader benefit before introducing the tools” can help future assignments.
save the useful principle with an example. that gives the next draft a better starting point.
make the useful jobs recurring
after the full workflow works on repeated examples, choose one recurring assignment.
a weekly idea shortlist.
a content performance report.
supporting posts for each newly approved article.
include the Jev evaluation step in the workflow you test before scheduling it.
ask for a simple delivery:
Return:
- the research or finished drafts
- a short summary of changes made during review
- unresolved checks
- editorial decisions that need me
Keep the summary brief.
Include detailed evaluations and sources separately.
Do not publish or contact anyone.
you should be able to open the result and understand what deserves your attention.
the build sheet
the complete setup:
your goal + source material -> Viktor plans and creates -> code and Jev check -> Viktor revises -> you review
-> workspace: Viktor, connected to your content files and relevant tools -> context: your audience, published examples, research and analytics -> review: code for mechanical checks, Jev for focused editorial judgments -> revision: failed requirements return to Viktor with the relevant evidence -> stopping rule: two revision rounds, then unresolved issues come to you -> memory: approved editorial lessons saved for future assignments -> delivery: drafts, a short review summary and the decisions that need your input
give your employee his first job
pick one piece of work you keep putting off.
the weekly report, or a content batch that eats your entire friday.
give him the source material, define what a good result looks like, and run it through the loop:
create -> evaluate -> revise -> evaluate again
start with one job. check whether the system catches the mistakes you normally have to explain. improve the checklist, then give him the next assignment.
over time, those repeated corrections become instructions your employee can act on before the work reaches you.
that’s the payoff: less time managing every draft, more time deciding what happens next.
start with Viktor as your AI employee, then connect Jev using the setup above.
give him one real assignment today. see how much closer he can get the work to finished before you step in.
Try free at @viktor_com. $100 in credits, no card. Full link in my first reply.
Paid Partnership
