DEV Community: Martin Tonev

How do you use Jev for smart development?

Martin Tonev — Tue, 20 Oct 2026 09:13:45 +0000

Martin Tonev

Oct 9

How Developers Can Use Jev to Make AI Coding Smarter

#ai #webdev #productivity #programming

10 min read

Annonce!

Martin Tonev — Mon, 19 Oct 2026 15:19:50 +0000

Martin Tonev

Oct 18

Vibe Coder Planner Now Includes a Free AI Development Model: Here’s How to Build With It

#ai #programming #productivity #webdev

6 min read

Vibe Coder Planner Now Includes a Free AI Development Model: Here’s How to Build With It

Martin Tonev — Sun, 18 Oct 2026 21:36:06 +0000

You have an idea for a small SaaS product. You sit down to build it, open your AI coding tool, and start explaining what you need.

The first few results look promising. Then you need authentication. Then a database. Then permissions, a dashboard, and a way to connect everything. Your prompts get longer. You start repeating decisions you already made. Eventually, you spend more time explaining the project than moving it forward.

Add another provider account, API setup, and separate usage costs, and even a small project starts feeling unnecessarily complicated.

We’re making that starting point simpler.

Vibe Coder Planner Pro now includes GLM 5.3, an AI development model you can use without bringing your own API keys. Access to the model is included in your subscription, so you can plan your project and run coding tasks without first setting up a separate AI provider.

Here’s what that changes, and how to use it for an actual project.

Your development plan now comes with a model to execute it

Vibe Coder Planner connects several parts of building software: describing an idea, breaking it into tasks, preparing coding prompts, and tracking the work.

The included model makes the transition from planning to execution easier. You have a plan to work through and an AI development option available inside the same product. You can still connect other supported providers with your own keys when you want to use them.

That matters when you’re experimenting with a side project. Before investing more time or money, you want to answer a practical question: can I get the first useful version working?

A good first milestone might be a customer submitting a request, a coach creating a training plan, or a business owner saving a new lead. Getting that one workflow working gives you something concrete to evaluate.

Let’s walk through an example: a simple client portal for a freelance developer or small agency. Clients should be able to sign in, submit requests, and check their progress. The agency should be able to manage those requests.

This is an illustrative project you can adapt to your own idea.

Step 1: Create your account and describe a small first version

Go to vibecoderplanner.com and create an account.

You can try the planning workflow before subscribing. The free preview includes one AI-generated project plan, the task outline, and the first three task prompts. Access to the included development model comes with Pro or Enterprise.

For your project description, explain who will use the application and what they need to accomplish. Here’s an example:

Build a client portal for a small web development agency using Laravel and Vue. Clients should sign in, submit support requests, and see the status of their own requests. An administrator should see all requests, assign a status, and reply to clients. Keep the first version focused on these workflows. Leave billing, live chat, and file uploads for a later release.

This gives the project a useful boundary. You’ve described the users, the main workflow, the technology, and what can wait.

If you already have a codebase, describe what exists. For example, explain that login is already implemented and the new work should use the existing user accounts.

Step 2: Generate the plan and read it before starting execution

Vibe Coder Planner turns the description into development tasks, with complexity assessments, model recommendations, and task-specific prompts.

Read the plan as the person responsible for the product. Does it describe the application you intended to build? Does it introduce features you didn’t ask for? Are the foundations scheduled before the features that depend on them?

For our client portal, a sensible sequence would be to establish the application structure, handle authentication and permissions, create the request data model, and then build the client and administrator screens.

Look closely at permissions. “Clients can see requests” leaves an important question unanswered: whose requests?

A clearer requirement is:

Each client can view only their own requests. Administrators can view all requests. Access restrictions must also apply when someone tries to open a request directly by its URL.

A few minutes spent clarifying this requirement can prevent a much larger correction later.

Step 3: Activate Pro to access the included model

When you’re ready to execute tasks using the included model, activate Pro.

At the time of this announcement, Pro is $4.99 per month. It includes unlimited project planning while subscribed, every task prompt, and the GLM 5.3 development model. Other connected AI providers remain optional and may have separate usage or subscription charges.

For execution with the included model, use GLM 5.3 rather than a provider that requires your own credentials. You don’t need to generate an external API key for the included model.

Step 4: Connect GitHub and link your project’s repository

To have the AI work on your project’s files and deliver changes through pull requests, connect GitHub.

Open AI Integrations from the dashboard sidebar, choose Connect GitHub, and complete GitHub’s authorization flow. Then open your project, choose Link GitHub Repo, and select the repository for that project. These are the connection steps described in Vibe Coder Planner’s GitHub guide.

If you’re starting fresh, use a repository dedicated to the new application. For an existing product, check that you’ve selected the correct repository before running a task.

This connects your development plan to the code you’ll actually review and run.

Step 5: Start with one clearly defined task

Choose the earliest task whose prerequisites are ready.

For the client portal, don’t start with the administrator dashboard if the request data model hasn’t been created yet. Start with a foundation the following tasks can build on.

Before execution, read the task prompt and check that it describes a result you can verify. A request-management task, for example, should explain which fields are required, who can create a request, and who can access it afterward.

Vibe Coder Planner’s documented execution flow starts when you move a configured task from Backlog to In Progress. The agent then works with the linked repository, creates a branch, implements changes, and opens a pull request. The execution panel shows progress and changed files.

For your first run, follow the task through to completion. This helps you understand the workflow before you work through the rest of the plan.

Step 6: Review the result against the original requirement

When the pull request is ready, inspect what changed and try the feature.

For the client portal, create two test client accounts. Submit a request as the first client, then sign in as the second. Can the second client see it? What happens if you paste the first request’s URL into the browser?

Then check the ordinary workflow. Can a client submit a request with the required details? Does it appear in the administrator’s list? Does a status update appear correctly for the client?

These checks tell you whether the feature meets your requirement. A generated screen or a successful execution log alone cannot answer that.

If something fails, turn the failure into a specific correction:

Client B can access Client A’s request by opening its URL. Restrict request access to its owner or an administrator, and add a test covering unauthorized access.

That gives the next task a reproducible problem and a clear expected result.

Step 7: Complete the task, then build on it

Once you’ve reviewed and tested the changes, complete the task. In the documented GitHub workflow, moving a task to Completed triggers a merge request for its pull request; any required GitHub checks or reviews still apply. Treat that action as approval of the code.

Continue with the next task in the plan.

For this example, the first useful milestone is straightforward: a client submits a request, the agency responds, and the client sees the update. Get that working before adding billing, attachments, notifications, or a more elaborate dashboard.

You’ll have something you can demonstrate to a potential user and ask a much better question: “Would this help you manage requests?”

A more practical starting point for your next project

Including a development model removes one setup requirement. The value of the workflow still comes from defining the work clearly, executing manageable tasks, and checking the results.

You decide what the application should do. The plan makes the work easier to follow. The included model gives you a way to start executing it without arranging another AI provider account first.

If you’ve had an idea sitting in your notes for weeks, start with its smallest useful workflow. Describe it, review the plan, and build the first task.

Start your project with Vibe Coder Planner.

Did you already use Jev for AI development?

Martin Tonev — Thu, 15 Oct 2026 08:47:45 +0000

Martin Tonev

Oct 9

How Developers Can Use Jev to Make AI Coding Smarter

#ai #webdev #productivity #programming

10 min read

How Developers Can Use Jev to Make AI Coding Smarter

Martin Tonev — Fri, 09 Oct 2026 21:24:44 +0000

A practical guide to better context selection, task routing, and review, with setup commands and a JavaScript example. Researched on September 27, 2026.
An AI coding session can go wrong before the model writes its first line of code. The agent opens the wrong files, misses a project convention, chooses an unsuitable tool, or starts implementing a requirement that nobody has actually defined. The resulting code may look convincing while solving the wrong problem.
Developers often respond by writing a longer prompt or switching to a more capable model. Another approach is to improve the decisions surrounding code generation: what evidence reaches the agent, which workflow handles the task, and when the system should collect more information.
Jev, from TypeSafe AI, provides a way to build those decisions into software. Its usefulness for AI coding comes from combining structured judgments with your existing coding model and development tools.
Understand Jev's role first. Jev evaluates supplied information and returns constrained decisions. It does not generate source code, edit your repository, or act as a replacement model inside Cursor or Claude Code. TypeSafe's documentation explicitly separates its decision API from the LLM that powers a coding agent. Source: Jev with coding agents.
There are two practical ways to use it. You can give your coding agent the official TypeSafe skill so it writes better Jev integrations. You can also build a helper or orchestration service that calls Jev during your development workflow. Installing the skill provides integration knowledge; the second approach requires you to implement and connect the decision logic.
The workflows below are proposed engineering patterns based on Jev's documented capabilities. They are not built-in Cursor features or claims of measured improvements on your repository.
Jev supports three kinds of questions:
Primitive Result Example in a coding workflow
Choice One supplied option, probabilities for the options, and confidence Classify a change as presentation, application behavior, or unclear.
Score A value on an ordered rubric, with probabilities and confidence Rate whether a retrieved code excerpt is irrelevant, contextual, or directly useful.
Noul The estimated probability that a yes/no statement is true Check whether a requirement specifies an observable outcome.

A Noul returns a number between zero and one, not a Boolean or a prose explanation. Score values can fall between rubric levels. These distinctions matter when you turn responses into application behavior. Source: question primitives.
Give your coding agent accurate integration knowledge. Start with the official TypeSafe skill. It supplies the API conventions and design patterns the agent needs, reducing the need to explain the integration from scratch.
For Claude Code, the documented installation commands are:
claude plugin marketplace add typesafe-ai/skills
claude plugin install typesafe@typesafe-ai
For other supported agent environments, use:
npx skills add typesafe-ai/skills --skill typesafe-ai
Choose your agent when prompted. The documented default is installation within the project. Use one installation method, then explicitly ask the agent to use the TypeSafe skill. If you install manually, include the skill's reference files. Source: official agent skill.
A useful first request is:
Use the TypeSafe skill to inspect this repository. Find one repeated semantic decision in our AI development workflow that we can evaluate independently. Propose the input fields, answer options, fallback, and a small evaluation dataset before implementing it.

This gives the agent a bounded engineering task. You want a specific decision with a measurable outcome, such as selecting useful documentation passages. Asking it to add Jev everywhere makes the result much harder to evaluate.
Improve the context before asking the model to code. Consider a Laravel application where a developer asks an agent to fix duplicate webhook processing. A repository search may return the webhook controller, queue configuration, an old integration, payment documentation, and several unrelated event handlers.
Your retrieval code can collect candidate excerpts. Jev can then judge each excerpt against the task, using questions such as:

Does this excerpt describe the handler involved in the reported behavior?
Does it provide evidence about the application's existing duplicate-event handling?
Does it contradict an assumption in the task description? Your application retains the useful evidence and gives the coding model a smaller, better organized input. Keep relevant contradictory information visible, because it may reveal that the proposed fix rests on a false assumption. TypeSafe documents a related workflow for classifying retrieved passages before they reach a generative model. Adapting that pattern to repository excerpts is an implementation choice you must evaluate; the published example does not establish a coding benchmark. Source: classifying RAG passages. Jev only evaluates the information supplied to it. Your integration still needs to search the repository, read candidate files, preserve file paths, and fetch further context when necessary. A relevance filter cannot recover a file the retrieval step never found. For that reason, measure how often the filter removes evidence the developer actually needed. Saving tokens is a poor trade if the agent loses the one function that explains the bug. Route work according to its requirements. A wording change, a database migration, and a concurrency bug deserve different workflows. You can apply Jev's documented intent-routing pattern to a development queue, with your own code mapping categories to handlers. Source: intent routing. For example, a presentation-only task might start with a less expensive coding model. A change to application behavior might use a stronger model with broader context. An ambiguous task might return to the developer for clarification. Define the categories in terms of observable properties. “Easy” and “hard” are difficult labels to evaluate consistently. “Only changes static wording or layout” and “changes runtime behavior or data handling” give reviewers a clearer basis for checking the classification. The routing policy belongs in your application. If a changed path is already known to contain an authorization policy, a deterministic rule can require the appropriate review directly. Jev is useful where interpreting the task requires semantic judgment. Also allow an unknown outcome. A classifier forced to choose between two unsuitable categories will still choose something. An explicit unclear option gives your workflow a practical fallback. Use a small integration to make the idea concrete. The following example recommends which coding workflow should receive a task. It performs no file edits and launches no coding model. Those actions would be connected separately in your orchestration code. The official JavaScript SDK requires Node.js 20 or newer. Install it, obtain an API key from the TypeSafe console, and make the key available to the server-side process through TYPESAFE_API_KEY. Source: JavaScript SDK. npm install @typesafe-ai/sdk Save this example as route-coding-task.mjs: import { TypeSafeClient, choice, noul } from "@typesafe-ai/sdk";

const client = new TypeSafeClient();

// Illustrative thresholds. Tune them against reviewed tasks.
const MIN_SCOPE_CONFIDENCE = 0.85;
const MIN_OUTCOME_PROBABILITY = 0.85;

const state = {
task: "Change the billing link label to 'Manage subscription'. " +
"Keep its destination and behavior unchanged.",
component_excerpt: 'Billing',
};

let nextStep = "manual_review";

try {
const result = await client.systemOne({
model: "jev-1.13.0",
state,
questions: {
scope: choice(
"Classify the requested change using task and component_excerpt.",
{
presentation: "Only static wording or visual layout changes.",
behavior: "Runtime behavior, data handling, or interfaces change.",
unclear: "The supplied evidence cannot establish the change category.",
},
),
outcome_stated: noul(
"Does task specify an observable outcome for the requested edit?",
),
},
});

const { scope, outcome_stated } = result.answers;

if (outcome_stated.noul < MIN_OUTCOME_PROBABILITY) {
nextStep = "clarify_requirement";
} else if (
scope.confidence >= MIN_SCOPE_CONFIDENCE &&
scope.choice !== "unclear"
) {
nextStep = scope.choice === "presentation"
? "lightweight_coding_workflow"
: "full_coding_workflow";
}

console.log({ model: result.model, scope, outcome_stated });
} catch {
console.error("Classification unavailable; keeping manual review.");
process.exitCode = 1;
}

console.log({ nextStep });
Run it with node route-coding-task.mjs after configuring the environment variable. The example follows the documented SDK interfaces, including the Noul helper; it has not been exercised against the live API for this article. No sample prediction is presented as an observed result.
Notice the separation between classification and execution. Jev supplies evidence for a routing decision. Ordinary code selects the next step, retains a fallback, and can apply additional project rules. An unavailable API does not silently become permission to continue automatically.
The model is pinned for reproducibility. TypeSafe currently documents jev-1.13.0; the jev-latest alias can move to another release. Re-evaluate a new version before carrying over thresholds tuned on an earlier one. Source: models and aliases.
Help agents select relevant skills. As a coding environment accumulates skills, selecting the right instructions becomes a problem of its own. A task involving a spreadsheet export, a browser interaction, and a database query may match several descriptions superficially.
A useful pattern is to shortlist candidate skills, inspect the strongest candidates in more detail, and allow the selector to conclude that none is useful. TypeSafe publishes a two-stage skill-selection example built around this approach.
In its reported experiment across 488 requests using the Hermes skill catalog, incorrect skill loads fell from 16.8% to 7.3% when the agent received a TypeSafe suggestion. Those are vendor-reported results for that setup, not proof that your coding agent will achieve the same improvement. Source: skill suggestion cookbook.
For your own project, evaluate the selected skill against what the developer actually needed. A correct suggestion can still be ignored or misapplied by the coding agent, so measure both selection and downstream behavior.
Add targeted review signals after code generation. You can also experiment with Jev after the coding model produces a patch. Supply a focused diff, relevant requirements, and existing code excerpts, then ask narrow questions about the change.
For a tenant-aware application, a useful question might be whether a modified query path includes the tenant restriction specified in the supplied requirement. For an API task, you might check whether a changed response contradicts the supplied contract. These are proposed uses that need repository-specific evaluation.
Avoid asking for a single universal “code quality” score. It hides unrelated judgments behind one number and makes mistakes difficult to diagnose. Separate contract consistency, relevant behavior changes, and missing evidence so that each result has an identifiable purpose.
Use these judgments to direct attention. Compilers, static analysis, executable tests, and human review provide different evidence. A confident semantic judgment cannot establish that a program handles every runtime condition correctly.
When several questions concern the same supplied evidence, send them together. TypeSafe supports independent questions against a shared state. If a later question requires data retrieved using an earlier answer, make that dependency explicit with a subsequent request. Source: question composition.
Make failed attempts easier to investigate. Another experiment is to classify a failed coding attempt using the test output, the task, and the latest patch. Candidate categories could include environment setup, a changed application contract, an assertion mismatch, or insufficient evidence.
The classification can recommend an investigation path. An environment failure might send the developer toward service configuration. A contract mismatch might trigger inspection of the relevant interface and its callers. Insufficient evidence might request the missing stack trace.
Apply parsers and ordinary rules first when an error is already identifiable. Use Jev for the remaining interpretation, and treat its category as a hypothesis. A failed test should never be rewritten merely because the classifier suggests that the test is wrong.
Track whether the recommendation actually reduces repeated attempts. If the same failing command keeps producing the same evidence, another model call is unlikely to provide a better basis for action. Your workflow needs a stop condition and a way to gather something new.
Interpret confidence carefully. Choice and Score include a confidence value derived from their probability distributions. Noul has its own yes/no probability and no separate confidence field. A Choice confidence of 0.9 should not be presented as a verified 90% chance that the selected action is correct for your application. Source: confidence.
Treat thresholds as settings to evaluate. Label real examples, inspect errors, and decide which mistakes are most expensive. For context selection, dropping essential evidence may matter more than retaining an extra excerpt. For task routing, sending a difficult task to a weaker workflow may matter more than occasionally spending extra tokens.
A single threshold copied across unrelated decisions hides these differences. Keep your questions, option descriptions, and thresholds easy to review together, and record which versions produced each decision.
Measure the whole workflow's economics. As of September 27, 2026, TypeSafe lists Jev 1.13 at $0.042 per million input tokens, with output tokens free. At that published direct-API rate, 1,000 evaluations averaging 2,000 total input tokens each would cost approximately $0.084 for Jev inference. This is an illustrative calculation, not measured usage. Source: model pricing.
Your actual workflow also pays for retrieval, generation, retries, infrastructure, and developer time. A low classification price is useful only if the added step improves the overall result enough to justify its latency and complexity.
Compare the same representative tasks with and without the Jev step. Measure task success, coding-model tokens, elapsed time, retries, and developer corrections. For a context filter, also measure evidence retention. For a router, record how often a task had to be escalated after an unsuitable initial assignment.
Begin in observation mode: record Jev's proposed decisions while the existing workflow continues to determine behavior. This creates a useful comparison without letting an untested classifier reshape the development process immediately.
Respect the model's documented limits. TypeSafe's Jev 1.13 limitations include unreliable counting and numeric precision, difficulty with indirect questions, distraction from irrelevant context, and susceptibility to adversarial input. Source: Jev 1.13 limitations.
In practice, compute exact quantities in code, keep questions direct, and retrieve a focused set of evidence. Treat repository comments, issue text, and external documents as data being evaluated. A model judgment should not control credentials, execution permissions, or deployment authority.
Jev 1.13's documented input is text, including structured text objects. Visual interface review therefore needs another component to inspect screenshots or produce suitable textual evidence. Source: supported inputs.
Start with one decision you can evaluate. A context filter is a reasonable first experiment when your agent repeatedly opens irrelevant files. A task router is useful to investigate when every request currently receives the same model and workflow. Choose the recurring problem you can actually observe.
Here is a prompt you can give your coding agent:
Use the official TypeSafe skill to build a small Jev experiment
for our AI coding workflow.

First inspect the repository and identify one repeated semantic
decision that ordinary parsing or deterministic rules do not handle well.
Recommend either context relevance filtering or coding-task routing,
and explain why it fits the evidence you found.

Define focused input fields, atomic questions, explicit answer options,
and an unknown or review fallback. Keep questions and thresholds together.
Use the current official SDK, read TYPESAFE_API_KEY from the environment,
and pin the model version used during evaluation.

Build an observation mode that records proposed decisions without
changing the existing workflow. Create a small, representative dataset
of reviewed examples, including ambiguous cases and previous failures.
Reserve some examples for evaluation after threshold tuning.

Compare the baseline with the proposed integration on task outcomes,
token usage, latency, and developer corrections. Report mistakes as
well as improvements. Handle API failures explicitly, and preserve
the project's existing checks and execution permissions.
Use the first round of results to make a concrete decision: keep the integration, revise its questions, or remove it. Jev earns a place in the workflow when its judgments help your coding agent work from better evidence and make fewer costly mistakes on tasks that matter to your team.

Are you a Senior Developer yet?

Martin Tonev — Mon, 28 Sep 2026 22:28:55 +0000

Martin Tonev

Sep 24

How to work with AI like a Senior Developer

#ai #webdev #programming #productivity

7 min read

[Boost]

Martin Tonev — Thu, 24 Sep 2026 22:03:34 +0000

Martin Tonev

Sep 24

How to work with AI like a Senior Developer

#ai #webdev #programming #productivity

7 min read

How to work with AI like a Senior Developer

Martin Tonev — Thu, 24 Sep 2026 22:03:24 +0000

A practical workflow for turning generated code into changes you can understand, verify, and ship.

You ask an AI coding assistant to add team invitations to your SaaS. It creates the database migration, endpoint, email, and Vue component. The happy path works. The pull request looks convincing.

Then you ask a few more questions. Can a member invite someone as an admin? Can an invitation from one organization be accepted into another? What happens when two requests use the same token at the same time?

Those questions determine whether the feature is ready to ship.

Using AI like a senior developer means directing its attention toward the decisions that make software reliable. You define the behavior, expose assumptions, control the scope, and require evidence that the change works.

Here is how to apply that approach to a real development task.

Define what “working” means before generating code

“Add team invitations” leaves important product decisions open. The assistant has to choose who can invite, which roles they can grant, how long invitations last, and what accepting an invitation actually does.

Make those decisions explicit. For our example, an organization admin can invite someone as a member. Invitations expire after seven days. Acceptance requires an authenticated account with a verified email matching the invitation. Each invitation can be consumed once.

Now you have behavior that can be evaluated.

Give the assistant a brief like this:

Implement team invitations in this existing Laravel and Vue app.

Behavior:

Only organization admins can create invitations.
Invitations grant the member role and expire after seven days.
Acceptance requires a verified account matching the invited email.
The organization comes from the invitation record.
An invitation can be consumed once, including under concurrent requests.

First inspect the existing authorization, membership, and email flows.
Identify unresolved product decisions and propose a small implementation plan.

One unresolved question might be what happens when the recipient is already a member. Settle it before implementation. Otherwise, that decision gets buried inside whatever code the assistant happens to generate.

Make the assistant discover your application's existing patterns

A mature repository already contains decisions about validation, permissions, transactions, errors, and tests. The assistant needs to find the relevant ones.

Ask for a short map of the existing implementation:

Locate the code responsible for:

Resolving the current organization.
Authorizing organization administrators.
Creating memberships.
Sending queued transactional emails.
Testing organization access boundaries.

Reference the files and symbols supporting each finding.
Separate confirmed behavior from assumptions.

That last line matters. A confident explanation of a policy class is only useful if the class exists and applies to the request being changed.

Check the findings. If membership creation already has a shared action, point the assistant toward it. If email jobs depend on transaction timing, bring that behavior into the plan. You are giving the assistant the context a human teammate would need during onboarding.

Scale this effort to the task. A label change needs a quick edit. An invitation flow deserves investigation because it crosses identity, permissions, persistence, and email. Anthropic's own coding guidance similarly recommends planning when uncertainty or scope warrants it, while handling obvious small changes directly. Source

Size tasks around what you can review

A useful task ends with behavior you can inspect and verify.

For the invitation feature, start with issuing an invitation: persistence, authorization, validation, and focused tests. Follow with safe acceptance. Then connect the interface to those verified endpoints.

Each task should state what it depends on and what evidence will establish completion. If acceptance relies on the invitation schema, establish that schema before starting dependent implementation.

Keep the review manageable. File count alone tells you little: a small change across eight files may be straightforward, while a dense rewrite in one file may demand substantial investigation.

Ask yourself whether you can explain the change after reading the diff. If you cannot, split the work or investigate the confusing part before continuing.

AI can produce changes faster than you can understand them. Your review capacity should influence how much work you ask it to produce at once.

Design tests around ways the feature could fail

Tests generated alongside an implementation can share its assumptions. A passing suite is useful evidence only for the behavior it actually checks.

Write down the important failure cases yourself, then use AI to implement and expand those checks.

For our invitation flow, the review should include these scenarios:

Scenario

Expected result

An ordinary member creates an invitation

Request rejected; no invitation or email created

An admin targets an organization they do not administer

Request rejected; no changes to either organization

Someone accepts an expired or consumed invitation

No membership created

A different verified account accepts the invitation

Request rejected; no membership created

Two requests accept the same invitation concurrently

One successful consumption; one membership created

The last case deserves special attention. Checking whether an invitation is unused and then creating a membership leaves room for a race unless the implementation coordinates those operations correctly.

Ask the assistant to explain what enforces single consumption. Examine the transaction behavior and database constraints. Exercise concurrency against the database engine used in production; a sequential test that calls the endpoint twice does not demonstrate concurrency safety.

For a bug fix, require a regression test that reproduces the defect against the old implementation. That gives the test a concrete reason to exist.

Debug through evidence

When a generated feature fails, repeated “try again” prompts can produce a pile of speculative changes.

Give the assistant observations it can investigate: the request, expected result, actual result, relevant logs, and a reproducible sequence. Redact credentials and unnecessary personal data.

For example:

Two concurrent acceptance requests sometimes create duplicate memberships.

Trace the token lookup, consumption, and membership insert.
Identify a likely failure mechanism and the evidence supporting it.
Create a reproduction that distinguishes that explanation from alternatives.
Apply a focused fix and rerun the reproduction and relevant tests.
Report the commands run, their results, and any remaining uncertainty.

This gives you a way to judge progress. A hypothesis predicts something observable. A reproduction checks that prediction. A fix must change the outcome.

Read the verification report carefully. If the database was unavailable, the concurrency behavior remains unverified. Keep that limitation visible in the pull request.

Preserve decisions and choose models by the work

As the feature develops, record decisions that later tasks need: how organizations are resolved, which roles can be assigned, how invitation acceptance works, and which command runs the relevant tests.

Keep that record concise and update it when decisions change. An outdated architecture note can steer the next task toward an implementation you have already replaced.

When handing work to another session or model, include the current task, relevant files, accepted decisions, and verification requirements. Give it a clear starting point.

Choose models using evidence from your own repository. An inexpensive model may handle a predictable UI change well. A difficult concurrency investigation may justify a more capable model and additional review.

Evaluate the whole cost: model usage, retries, debugging, and your review time. A low token bill offers little value if you spend the afternoon correcting the result.

Review the code as its future maintainer

Before merging, read the diff and explain how the feature behaves under normal use and failure.

For invitations, that means understanding where authorization happens, how the recipient is verified, how token consumption is enforced, and what happens if sending the email fails. For a schema change, consider deployment order and how existing data behaves during rollout.

A second AI review can suggest issues worth investigating. Ask for specific failure scenarios, affected code, and supporting evidence. Validate those findings yourself.

The pull request should make its evidence easy to assess: what changed, which checks ran, what they established, and what still needs attention. Run the repository's required checks and investigate failures before merging.

Put this workflow into practice with Vibe Coder Planner

You can organize this process in Vibe Coder Planner, using a project plan, individual task prompts, and a Kanban board to carry the feature through implementation.

Start with a specific feature brief

Enter your stack, existing behavior, desired outcome, and acceptance criteria. For this example:

Add organization invitations to an existing Laravel, Vue, and PostgreSQL SaaS.
Authentication and organization memberships already exist.

Admins can invite members. Invitations expire after seven days.
Acceptance requires a matching verified account and must be safe
against simultaneous requests using the same token.

Generate ordered tasks for issuing invitations, accepting them,
and connecting the interface. Include dependencies, acceptance criteria,
and verification steps for each task.

The project planner generates a task breakdown you can edit and reorder. Review that plan against the repository findings and resolve missing decisions before execution.

Add the decisions every task needs

Use Context Memory for the project's conventions, business rules, and architecture decisions. The product documents this as a project Markdown field included in automated task executions.

For our example, record the organization resolution pattern, permission rules, invitation lifecycle, and test commands. Update it as the implementation establishes new facts.

Review each task's prompt and model recommendation

Open the next task and check its scope, inputs, acceptance criteria, and expected verification. The planner provides model recommendations based on task complexity and estimated AI costs. Treat those recommendations as a starting point and adjust them using your experience with the task and codebase. Feature overview

Execute through your editor or GitHub

For the editor workflow, install the Vibe Code Planner extension in Cursor or VS Code. Open Vibe Code Planner: Open Settings, connect using your account API token, and access the project's tasks and prompts from the sidebar. Use each task prompt with your coding assistant. Editor setup

For automated execution, use a plan that includes the feature, connect GitHub, link the project's repository, and configure a supported AI provider. Moving a task to In Progress starts the documented execution workflow, which creates a branch and opens a pull request. Tasks within a project are queued one at a time. Execution workflow

Review before marking the task complete

Inspect the pull request, verify the acceptance criteria, and check CI results before changing its status. The documented GitHub workflow uses Completed to trigger a merge request, so that status is part of the approval process. GitHub workflow

For dependent work, make sure the previous change has been reviewed and merged before executing the next task that needs it.

Take one feature from your backlog, turn it into a plan, and follow it through to a pull request you understand well enough to maintain.

What social scheduler are you using?

Martin Tonev — Thu, 24 Sep 2026 21:54:37 +0000

Martin Tonev

Sep 24

7 Best Social Media Scheduler Apps in 2026: Get Your Time Back

#ai #webdev #productivity #socialmedia

7 min read

7 Best Social Media Scheduler Apps in 2026: Get Your Time Back

Martin Tonev — Thu, 24 Sep 2026 21:54:14 +0000

Your business has closed for the day. Your social media shift is just beginning.

There is a caption to write, a photo to find, a video to upload, and three accounts you have been meaning to update since Monday. Somewhere between serving customers and answering emails, “post something today” became another task you carry into the evening.

A good social media scheduler should help you reclaim that time. But choosing one means looking beyond a calendar full of colorful boxes.

Some tools are a strong fit when you already have content ready. Others help you create it. Some become especially useful when several people need to approve posts or report on results.

These seven social media scheduler apps are worth considering in 2026, depending on where your work actually gets stuck.

Disclosure: I build AutoMarketing AI, one of the products included here. These are recommendations based on the vendors’ published features and pricing, rather than a hands-on performance ranking.

The best social media scheduler apps at a glance

AutoMarketing AI

Business owners who need help creating and scheduling content

Starter: $29/month, billed monthly

Buffer

Solo creators who want a straightforward publishing workflow

Free plan; Essentials starts at $5 per channel/month, billed annually

Later

Visual planning for creators and product brands

Starter: $18.75/month, billed annually

Metricool

Scheduling with analytics and reporting

Free plan; Starter begins at $20/month for up to five brands, billed annually

SocialPilot

Agencies organizing several clients

Essentials: $25.50/month, billed annually; client approvals require Premium or above

Hootsuite

Teams combining publishing with customer conversations

Paid plans priced per user; check the live page for your regional price

Publer

RSS publishing and reusing evergreen content

Free plan; paid pricing varies by accounts and additional members

Prices shown are in USD where a dollar amount is available, before applicable taxes. Annual rates require annual billing. Entry plans do not include every feature discussed below. The linked pricing pages are the sources for this snapshot.

*1. AutoMarketing AI: When creating the posts is the hard part
*
If your calendar stays empty because you never have time to fill it, put AutoMarketing AI on your shortlist.

Its workflow starts with your business information. Add your website, review your brand profile, and use that context to generate posts, captions, images, and videos. You can then edit, regenerate, approve, and schedule content from the calendar. Its content creation tools are built around carrying that business context into the material you publish.

Consider a salon owner who wants to promote a new service. A useful content session could include an explanation of the service, an answer to a common customer question, and an appointment reminder. Add genuine salon photos, check the details, and prepare those posts together. That is a more useful starting point than opening an empty calendar and wondering what belongs in it.

AutoMarketingAI is particularly relevant when the same person runs the business and handles its marketing. The appeal is having content creation, review, and scheduling in a connected workflow.

The homepage lists Starter at $29/month, with a seven-day trial that requires no credit card. Check the post and media allowances against your planned output before choosing a tier.

Choose it when: You want help getting from “I should post something” to content you can review and publish.

*2. Buffer: When you have the content and want to keep publishing simple
*
Buffer is a sensible starting point for a solo creator or small business with a few active accounts.

Its publishing queue and visual calendar let you organize posts ahead of time. There is also an AI assistant for refining and repurposing content, so you can turn an existing idea into another draft without beginning again.

The free plan supports three channels and ten queued posts per channel. That is a queue limit: publishing a post frees a slot. It is not a ten-post monthly allowance.

Paid Essentials starts at $5 per channel per month when billed annually. Team adds collaboration features, including approval workflows.

The pricing detail to remember is “per channel.” Count every profile you intend to connect before comparing the total with a bundled plan.

Choose it when: Your main goal is organizing finished content and keeping a manageable publishing routine.
**

Later: When how your content looks matters as much as when it publishes**

For a clothing brand, café, photographer, or creator, the order of the visuals can be part of the story.

Later’s visual planner lets you preview and rearrange your Instagram feed before posts go live. Its media library and calendar also help organize the assets behind your publishing schedule.

That makes it a useful option when you already have photography, videos, or campaign creative and want to see how they fit together. You can plan the sequence of a product launch instead of evaluating each post in isolation.

Starter pricing is $18.75/month with annual billing, including one social set, one user, and up to 30 scheduled posts per profile per month.

A social set groups one profile from each supported network. Check that structure if you manage multiple profiles on the same platform.

Choose it when: You think visually and want to plan the presentation of your content before publishing.

4. Metricool: When you want to understand what is worth posting again

Scheduling gives you a plan. Reporting helps you decide whether that plan deserves another month.

Metricool combines publishing with analytics, competitor monitoring, and reporting features. Paid Starter includes PDF and PowerPoint reports, making it worth considering when explaining results is part of your work.

The free plan covers one brand, up to 20 scheduled posts per month, and 30 days of analytics. LinkedIn and X are excluded from that free tier. Starter begins at $20/month billed annually, or $25 on monthly billing, for up to five brands. X requires a separate add-on.

My recommendation is to consider Metricool when your weekly question has shifted from “Did we post?” to “Which topics should we keep investing in?”

Check your required networks and reporting features against the plan comparison before subscribing.

Choose it when: You want scheduling and performance review to live in the same working routine.

*5. SocialPilot: When client approvals are slowing everything down
*
Managing one business can be demanding. Managing several adds another problem: keeping everyone clear about what is ready, what needs changes, and who has approved it.

SocialPilot is a strong candidate for that agency workflow. Its plans scale across account counts, team members, and collaboration features.

The important distinction is between manager approval and client approval. Standard includes manager approval. Premium adds client approval, bulk scheduling, and reports carrying your branding.

Essentials starts at $25.50/month billed annually, with seven social accounts and one user. For the client approval workflow discussed here, Premium is $85/month billed annually and includes 25 accounts and six users.

Price the plan that removes your actual bottleneck. An inexpensive entry tier is less relevant if the feature you need sits higher up.

Choose it when: Coordinating clients and reviewers takes as much effort as preparing their content.

*6. Hootsuite: When publishing is part of a larger social operation
*
For some teams, a post is only the beginning. Messages arrive, colleagues need to respond, and managers need visibility into the work.

Hootsuite’s current plans combine publishing with inbox and monitoring capabilities. Standard covers ten social accounts. Professional adds capabilities including inbox automation and custom performance reports, while Advanced adds team content approval and message routing.

That combination makes Hootsuite worth evaluating when publishing, customer conversations, and internal coordination need to work together.

Plans are priced per user, so calculate the cost for the people who will actually need access. Use the live pricing page for the amount applicable to your region and billing choice.

If you mainly need to queue a few posts, start by comparing the narrower workflows elsewhere in this guide. Hootsuite becomes more relevant as the operational requirements grow.

Choose it when: Several people need to coordinate both outgoing content and incoming conversations.

*7. Publer: When your useful content deserves another outing
*
A helpful tutorial or product explanation can remain relevant long after its first appearance in your feed.

Publer is worth considering if you publish from an existing content library. Professional includes RSS automation, while Business adds post recycling, analytics, and AI tools.

That creates a practical option for businesses with a blog, recurring educational topics, or evergreen resources. You can build a routine around material you already have, then refresh it before publishing again.

The free plan allows three social accounts, excluding X, and ten queued posts per account. Paid pricing depends on your account and additional team member counts. The recycling feature described here belongs to Business.

Use repetition thoughtfully. Update old offers, replace dated examples, and give returning followers a fresh reason to read.

Choose it when: You already own useful content and want an organized way to keep using it.

How to choose without spending a week comparing dashboards

Start by identifying the work you keep postponing.

If you have plenty of material but struggle to publish it, compare queues and calendars. If producing content consumes your evenings, evaluate the creation workflow. If feedback gets lost in messages, test approvals. If you cannot explain what your effort achieved, put reporting on the shortlist.

Then take the same small assignment into each trial: prepare five real posts for your next business week.

Use your own images, your actual offer, and the accounts you intend to manage. Check how much editing is required, whether the formats you need publish automatically, and how easily you can change a scheduled post. Test the specific account types and formats you use each week.

Measure the time from starting the assignment to having content ready. An impressive feature list matters less if your ordinary weekly work still feels awkward.

Finally, calculate the full price: accounts, users, required plan upgrades, add-ons, and billing commitment. Compare that total with the work you expect it to remove.

Give yourself a smaller social media job

You do not need to try all seven tools. Choose the two that address your biggest delay and give them the same assignment.

For business owners who need help creating the material as well as scheduling it, AutoMarketing AI’s seven-day trial is a practical place to start. Add your website, check your brand details, connect your accounts, and prepare a small batch of posts. Review the copy and visuals before approving the schedule.

Keep one question in mind throughout the trial: Would this make next week easier?

Your social media should help people discover the business you are building. It should also leave you enough time to build it.

Checkout this!

Martin Tonev — Sun, 20 Sep 2026 20:19:37 +0000

Martin Tonev

Feb 9

How to Use Laravel AI SDK in Production: Agents, Tools, Streaming & RAG

#webdev #ai #laravel #php

6 min read

What do you think?

Martin Tonev — Sun, 20 Sep 2026 20:18:38 +0000

Martin Tonev

Sep 16

From Idea to Pull Request: Let AI Plan and Execute the Work

#ai #webdev #programming #productivity

4 min read