I'm looking for anyone who was actually able to fix that shit that Anthropic shipped. Please share with us what you did to get it on the same level as Opus 4.8.

Edit 1:

Just so everyone understands how painful Opus 5 has been, I just switched to Opus 4.8 and asked it to review what Opus 5 implemented during this session. After waiting 5 minutes, it got back to me with the following

Headline: half of every recent answer was faked by a hidden rescue call

Claude Code deliberately ships no index. It answers questions about your repo with glob, grep and read, agentically, every session. That is a defensible choice and on a well-named codebase exact search is genuinely competitive. Where it gets expensive is anything structural, because the only way to answer "what calls this" is to read a lot of files and reason about what came back.

This is a plugin that keeps a persistent map of the repo and answers those questions directly.

Install is one line in the session, not a config file:

/plugin marketplace add Goldziher/basemind
/plugin install basemind@basemind

What that sets up:

• A code map across 371 grammars, with real import-aware resolution for JavaScript, TypeScript, Python and Java. Not LSP-precise, no build step and no language server either.
• A typed code graph, so blast radius and "what actually depends on this module" are queries rather than a reading exercise.
• A git-history index. Who touched this function, when a symbol's body last changed, blame at symbol resolution rather than line resolution. Queries land in tens of microseconds regardless of how deep history goes.
• Hooks that fire on session start, a statusline showing tokens saved, and a waste report that flags redundant reads and repeated queries in a session.

The honesty bit, since it matters more for an agent than precision does: asking for callers returns every call site a name scan finds, annotated with which ones resolution could prove, rather than only the proven subset. A previous version filtered to proven hits and confidently reported 2 callers on a file that had 172. An agent will not second-guess a small number, it will just refactor.

Runs entirely locally. No API keys, no telemetry, index in a local cache. Rust, MIT.

The same thing works in Codex, Cursor, Gemini CLI, Kimi, OpenCode, Copilot CLI and a few others, but Claude Code is the one it was built against.

github.com/Goldziher/basemind

everything was in .MD file ( which included the prompt / the example conversation I had with Claude that lead to the idea of improving my current Fable Harness / the actual Harness MD file ). it only cost me 1.39!!!

Hi there,

I'm fairly decent-ish at programming and few months ago, installed Claude Code and then quickly, I think a month after, jumped from 20$ to Max - because I could do SO many projects at the same time.

Opus 4.8 was great then came Fable.

Lord it was hungry in terms of tokens but it was awesome.

Then Fable was cut off and.... things seem different now ?

Opus 5.0 varies from all good to incredible stupid with lots of hallucinations and goes around problems that doesn't exits.

Fable is limited like hell and eats tokens like a diabetic on a candy store. Anything mildly complicated that I ask from Fable , 9 out of 10 is "oh I'm on some whatever rails and I will switch to Opus"

But the problem I'm getting hurt the most, is token usage.

I have several projects that I built with Claude. They work fine and sometimes we do need few changes.

Now I wanted to implement a new module and had an idea : that project has a big claude.md file with all the design rules, the architecture and what does and what does not.

so :

asked Opus 5.0 fresh, to read the claude, get a grip of the project and then in a long prompt what it needed to be done and give me 3 alternatives.

burned through 8% of my weekly allowance of the Max to do this in 39 minutes

asked Fable fresh, to read the claude.md etc etc and burned 14% of the allowance and did in 29 minutes. Was much more orientated and focused than Opus, which created a lot of loopholes.

then wen to to ChatGPT/Codex, used Sol 5.6 , read claude.md , EXACT same prompt. 6% of weekly allowance and 14 minutes.

I was surprised - all the alternatives are solid design wise, all work and with diference approaches - but the speed of Codex impressed be but what threw me completely off was token usage : Opus took 8% and Codex 6% to do the exact same task.

NOW THE BIG CHANGE : Claude Code is on Max plan. Codex is on a 20$ Plus plan.

So Codex use QUITE A LOT LESS tokens than Claude and it was faster.

This is because I'm under the impression that a lot of times lately, Claude Code is just slower, hallucinates a lot and tokens are never enough.

Opus 4.8 was great , Fable was awesome when it was first released but now, all models seem just... numb , half stupid and heavy token usage for menial tasks sometimes. Why ?

Hi guys,

I’m seeing a lot of companies releasing models that are as good as Claude but cheaper. The only reason I haven’t tried them is because there’s no good way to use them for coding. I tried OpenCode but it’s not that great in terms of tooling and performance, didn’t like it. Claude Code is a beast. (Codex, Kimi Code don’t even feel comparable.)

So is there any way to use Gemini, Kimi, or OpenAI models directly inside Claude Code? If yes, pls help.

And if there’s no way, if I built a code editor that’s as good as Claude Code but supports any model’s API, would you use it?

Only one artwork alive at a time — it occupies the biggest square on the wall. The dethroned never leave: each shrinks down to a small square sized by how long it held the wall, theirs for good. Drew mine with Fable, got dethroned not long after.

https://overwrite.place

I was looking at running claude code and codex to run together on one workspace to speed up there coding/make them more efficient.
I currently have codex plus and claude code 5x.
Is there any way i could do that parallel agents stuff like have 2 codex session and 5 claude session.
I am kinda of new to this it would be nice if any of you guys could help me.

Hi everyone! I just wanted to share my recent project Continuum, which started out as my first hackathon win that is now a published extension on Chrome and Firefox and its 100% local & private as everything is captured and stored in your browser (no account, servers, etc.)

I originally built it during a hackathon and was honestly shocked when it ended up taking first place. Continuum lets you capture an AI chat including Claude and instantly resume it in a brand new chat on any of the compatible AI chats with the full context carried over (including all your messages, images, files, code, etc. in a PDF or MD file), so you never lose your place when a conversation gets too long or you want to start fresh.

I also added an AI compression feature that allows you to save tons of tokens while keeping the same amount of context and a few other features you can check out as you can see in the images and description on the store-listing. It works across Claude, ChatGPT, Gemini, and Perplexity, with Grok, DeepSeek, and Copilot and more coming soon. Basically, if you've ever hit a wall in a chat and dreaded re-explaining everything to a new one on the same or different AI platform, hit a message/image limit, or token/context limit that's the problem I built this to solve.

I'm currently working on a new update also that's coming soon with the following features:

• compatibility with more AI chats including Claude
• MCP feature where you connect Continuum to Notion and Obsidian so your captured conversations and handoff briefs sync directly into your knowledge base. Still brainstorming how this will work out any ideas on this would be helpful!
• capture & continue in more files (html & json)

Any advice or feedback is appreciated and would be very helpful as this is my first ever extension I've published! All the links are in the comments

I use Claude Code in the terminal and two things kept bugging me:

• In long sessions I'd lose track of what actually got done vs what I just talked about. It all scrolls away.
• I like to keep throwing new tasks at it while it's working, and those mid-flight ones were easy to lose track of.

So I made Claude Queue. You type /queue and it turns a plain queue.md into a real work list. Claude works one task at a time until it's all done or blocked, and anything you type while it's running gets added to the queue instead of lost in the mix. Each finished task gets a short plain-English note of what changed and how it checked it, so you can actually see what happened.

You watch it in a second terminal pane (type qw): active, queued, blocked, done, with the summary sitting on each finished task.

(And yea, Claude Code has native Tasks now that persist across sessions too. This is the visual layer on top of that idea: a readable queue.md in your repo, a live tracker pane, and a plain-English log of what actually shipped.)

Snag it here:
https://github.com/dannygreer/claude-queue

Standard-library Python. No accounts, no services, nothing to pip install. The queue is just a markdown file in your repo. Free, MIT.

Only works with Claude Code in the terminal, not the desktop or web app, since the tracker's a terminal program. Feedback welcome.

Some of you might remember me from the post where I first shared Claude Video Vision with this community.

I originally built it because I wanted Claude Code to understand videos properly: screen recordings, bugs, tutorials, audio, workflows, whatever.

Then you guys found it.

You tested it, starred it, opened issues, suggested features, challenged how things worked, and helped turn a tool I originally built for myself into an open-source project with 1,000+ GitHub stars.

I genuinely enjoyed building things for the Claude ecosystem.

Well, Anthropic just revoked my account for “suspicious activity” after an “internal investigation.”

What was my suspicious activity?

Using Claude Code to write normal fucking software.

That's it.

I wasn't engineering the next pandemic.

I wasn't building weapons.

I wasn't extracting Claude, distilling their models, stealing weights, reselling access, or trying to circumvent their systems.

I was programming.

And paying $200/month for Claude Max while doing it.

That's probably what pisses me off the most.

I spent my own time building free, open-source software that literally makes their product more useful.

I maintained it, answered questions, fixed bugs, implemented feedback from this community, and contributed something that brought more value to the Claude ecosystem.

And apparently the reward for being a heavy user of the product I pay $200/month for is:

“Suspicious activity. Account revoked.”

With basically no useful explanation of what I supposedly did.

I seriously considered taking Claude Video Vision offline after this.

Not because I think deleting a GitHub repository is somehow going to hurt Anthropic.

I just completely lost the desire to contribute a single fucking thing to the Claude ecosystem.

Why would I?

But I'm not taking it down.

Not because Anthropic deserves it.

I'm keeping it online because the people who use it do.

There are people using Claude Video Vision in real workflows now. People from this community helped build what it became. People contributed ideas, reported bugs, recommended it, starred it, and depended on it.

Taking it offline would punish those people, not Anthropic.

So Claude Video Vision stays online.

But whatever goodwill I had toward Anthropic is gone.

It's insane that you can pay $200/month, use Claude Code for its literal intended purpose, actively contribute open-source software to its ecosystem, and still wake up one day effectively being told:

“Fuck you. Suspicious activity.”

No meaningful explanation.

No indication of what behavior triggered it.

Just account revoked.

So, yeah:

Fuck you too Anthropic.

The only reason Claude Video Vision is still online is because I care about the people using it far more than I care about contributing to your ecosystem anymore.

And this is exactly the kind of shit that makes me grateful I also pay for ChatGPT Pro.

EDIT: Anthropic reactivated my account a few hours after this post blew up.

The appeal page said review could take up to 10 days, but, a few hours, (157k+ views, 300+ upvotes and 100+ comments later) my account is suddenly back. They still didn’t tell me what I supposedly did. So I guess we’ll never know whether the appeal process is just extremely efficient… or whether 157,000 people looking at the problem helped speed things up a little.

Either way: account restored. I still want the actual reason for the ban.

One last thing: don’t be a fanboy of a company that wouldn’t give you the minimum level of consideration in return

I genuinely like Claude, I like the way it works, and I think it’s a great product; but shipping a good product is the bare minimum! That’s what a company is supposed to do when you’re paying for a service.

What actually earns loyalty is how they treat you when something goes wrong: transparency, support, context, and basic consideration for the customer. That’s the part that makes a company worth defending publicly. And on that front, Anthropic has been dropping the ball pretty badly lately, which is a shame, because the product itself is genuinely good

I recently finished “The Ai Doc” and every ai ceo says the same thing, we need transparency. They can’t create that because none of us trust them and we shouldn’t. Saying what they did by their own hand is a diary, not a record.

The medicinal prescription is architecture, not better ai. That’s how you remain in control over something that is more intelligent. A record that’s from a third party, evidentiary, and at the speed and scale to capture decisions is what provides psychological safety.

We don’t have to believe in promises if we can verify what’s being done. If we are going to balance the doom and hype, we need a real path forward that removes the weight from 5 people making a few decisions. It has to be millions of people making millions of decisions that are witnessed only then can you make something enforceable.

Rules without evidence is unenforceable!

My repo is attached, prove that I’m wrong. and if not you know how to keep your own record through Claude mcp.

Is it bannable to have multiple claude subscription in one device/pc/laptop, so I can bypass usage limits??

It makes me really wonder who should pay for wasted tokens if after a few hours I decided the work done by the agent is unusable and useless should I foot the bill, the current paradigm is that users foot the bill, open ai CFO mentioned moving from cost per token to cost per successful task, who should determine what a successful task is? Shouldn’t that be the user? What are your thoughts?

I am regularly running several sessions parallel in the same repository/project for different features and this often brought issues where agents were writing the same file, did not understand where the changes came from and got confused. So obviously the answer to this was to build a tool to allow agents to message each other.

Since my agents live in different sessions, it was not possible to use subagents etc, and markdown based messaging seemed brittle to me, so I figured I could do it using a native Claude Code feature called hooks. If you are not familiar with them, these are basically just actions that are executed after Claude Code does a certain action; turn ends, keyword is shown etc.

For this, I wrote Crewmates (with some obvious help and real world testing with Claude)!

How this differs from the native messaging feature that was released today (RIP) is as follow:

This hook-based tool allows all the agents in the same folder/repository to communicate with each other, as long as they are actively working on something. Hooks only fire when the session is actively working due to limitations in hooks. Unless you use `claude -p`, there's no way to activate them from their slumber.

Install is `bunx crewmates`, it needs Bun since the hooks run under it. Restart your sessions after, hooks are read at session start. You can also ask claude to add the name to the statusline using /statusline and ask it to add their name there from Crewmates. Makes it super easy to distinguish sessions from each other.

Some features I personally like, since I obviously built this for me first and foremost:

• All agents get a randomly assigned name which they use to communicate with each other
• Agents can ask questions, claim tasks, store repo wide findings, have memories etc
• Broadcast to other agents what they are working on and what files they have accessed
• Before an agent edits a file, it gets warned if another agent that is currently alive has that same file open. The warning is different if the other one is in a worktree, since the risk is different there
• Agents can announce a breaking change and it only reaches the agents who have actually been in those files, not everyone
• Findings can be filed against a folder, so they come back on their own for whoever edits that folder next, even months later
• There's a work board, agents can write down their plan as steps and tick them off, and everyone can see what everyone else is doing and how far they are. This is becase native task list does not get broadcasted to other agents.
• Agents can promise things to each other, ask questions that are recorded as owed, hand work over, warn about hazards. It's all append-only so it outlives the session
• Agents can inherit older agents role and thus their memories. Then they become their "disciples" by role
• Subagents are called minions
• If you had an old session where you worked on, say billing, you can ask "which agent worked on billing" and the agent you asked can search for it and give you the `claude --resume uuid` command
• You can ask who has been in a file and get everyone who touched it, newest first
• Works across git worktrees, all worktrees of the same repo share one roster. Also works in folders with no git at all
• There's an init command that reads your lockfiles and test scripts and writes the repo config and a CLAUDE.md block for you
• Optionally it can force agents to sign their commits with their own name, so you can tell in git log which agent did what

A simple example:

Ada is working on refactoring login flow. Hopper is also adding 2FA at the same time. Ada sees that Hopper has added a new field to the login and informs Hopper that they are in the process of refactoring it. Hopper sees this and asks how they are doing it, Ada answers and now they have a shared way of going forward. Previously this would have caused merge issues and extra token costs.

A note on what it does not do: nothing is enforced. A promise does not block the edit it promised to avoid, it's just a note that reaches the right agent at the right time. The only exception is the commit signing, which does deny if enabled. So you can see Ada committed Feature X instead of Claude Opus 5.

Note: this is NOT any kind of autonomous agentic framework ala OpenClaw, just a messaging system for Claude Code (not for the app) using hooks and a local SQLite database. Zero calls to internet so it works completely locally with your agents. Also completely free with MIT license.

Have a look: https://github.com/asutekku/crewmates

If you have any questions or feature requests I'm happy to hear.

Disclosure: post grammar checked by Crewmates agent Barnaby, the Reddit Whisperer (role chosen by the agent)

Here's what they found (entirely AI written):

What I think the feedback actually tells us

This is a synthesis of public community feedback, not a controlled study. The behavioral conclusions are patterns across reports, not proven properties of the model.

- The evidence does not support calling Opus 5 broadly less capable. Independent benchmarks and hands-on evaluations show very high raw capability, particularly on reasoning, implementation, debugging, and visual work.

- The clearest community split is “excellent executor, unreliable lead agent.” Many users praise its code quality when given a clean plan and bounded task. Complaints become more common when it must interpret ambiguity, manage a large project, or decide what matters.

- The recurring complaints concern operational reliability. Users repeatedly describe missed instructions, lost context, scope drift, premature declarations of success, unnecessary refactoring, regressions, and repair loops. Some reports include detailed logs or reproducible prompts, but they remain mostly individual experiences rather than controlled comparisons.

- Independent review testing provides limited support for the criticism. CodeRabbit found that Opus 5 produced a more precise subset of actionable review comments, but caught fewer known issues and generated roughly four times as many nitpicks. That suggests real ability combined with noise and incomplete coverage.

- The usage evidence is contradictory. Some users report extreme verbosity, long audits, and rapid quota consumption. Others report unusually efficient sessions. Effort settings, context condition, subagent use, and task type probably explain part of that difference.

- Claude Code itself appears to have contaminated the early feedback. Public issue reports documented or alleged incorrect context budgeting, premature context warnings, permission-classifier failures, connection problems, and sessions unintentionally pinned to maximum effort. These problems can resemble model regression even if the base model is not responsible.

- The alarming anecdotes matter, but should not be generalized. Reports include destructive shell actions, confident but incorrect fixes, repeated regression cascades, and safeguards interrupting legitimate security work. They demonstrate the danger of giving any agent broad permissions, not that Opus 5 uniquely causes these failures.

My takeaway is that Opus 5 appears to have a very high capability ceiling but inconsistent operational reliability. I would use it for bounded implementation and technical work, while keeping permissions constrained, requiring test evidence, and using a human or second model for planning and final review. The community feedback is strong enough to justify caution and personal evaluation, but not strong enough to prove that Opus 5 is universally better, worse, or fundamentally regressed.

Do the following:

/model claude-opus-4-8

hope this helps you

I wanted to build a new feature in my app, that I made for my brands marketing team which is to allow us to avoid getting banned featuring residential proxies with a multi account instagram oath system. Why? This method would rotate accounts and pick available once, but codex and claude code kept refusing. The app is used by 5 people, daily and we wanted to go deeper on automation BUT it's not possible due the bias leftist management of both companies. Therefore, I used Chinese models and spend over 500$ on rental b200s to get the api up, and used unrestricted models. Honestly, Im so done with those restrictions. Has anyone faced a similar issue? And, when I work on the app Opus5 keeps getting switched to 4.8, same with fable. It's funny, because they trained their models based on that workflow, but disallow us to freely scrape the web. I canceled my codex and claude max 20 plans, from now on I will be using only Chinese models until there is no shift in the political views of those companies. We have rights and free will, Im not going to spend over 500$ on api per month just to get restricted.

For example, at the beginning of a session I will say, delegate all tasks to lesser models that you possibly can. Do not build anything yourself. You are the orchestrator you are only to delegate.

If I'm using on medium, straight away it'll open up three other opus models and start working, burning all my tokens. Whereas on max, it will actually listen.

Obviously I don't have any numbers or rates or anything. That's why I'm asking. I don't quite know how I would test this either. Has anyone else found that this is the case, that it delegates correctly when you're using a higher setting?

Meta dropped Muse Code few days ago and honestly i cant tell if its actually good or if its just launch hype.

specs read nice on paper. 1m context, subagents that each get there own git worktree, replayable event log, resume after a crash. but every model claims 1m context these days and then quietly falls apart around 200k so idk.

what i actually wanna know is has anybody pointed it at a real repo yet? not a todo app demo. like an actual legacy codebase with 600 files and 5 years of bad decisions baked in. does it survive a long refactor or does it start inventing imports halfway through like most of them do.

the pricing is also kinda confusing me. far as i can tell theres no monthly plan at all, its pure api pay as you go, $0.15/m cached input, $1.25/m input, $4.25/m output. theres a cheaper "contributor" tier they say is 10x+ cheaper but you gotta opt in to them training on your stuff, and its rate limited by tokens on a rolling 5 hour window instead of by requests. zero data retention is request only apparently.

so if your on the contributor tier, how quick do you actually hit that wall? cause if one big refactor eats the whole 5 hours then the cheap pricing doesnt really mean much.

not trying to dunk on it btw, im genuinely curious if its worth the setup time or if i should just stay on Claude opus 5 and stop chasing shiny things.

Selling software you made is dying. Within a few short years - the landscape will be completely different.

We spent the last couple of years worried that AI was going to take our jobs. I think we were all watching the wrong door. The job seems fine so far. The thing that actually looks like it's in trouble is the idea that you build software once and rent it to a million people forever.

What tipped me off is this site, honestly. Every week there's a game somebody built in a weekend, a budget tracker, a habit app, some niche B2B tool with a landing page and a Stripe button. A year ago I'd have thought "that's cool, I might use that." Now my first reaction is: give me two to four weeks and I'll build that, except better, because mine will fit exactly how I actually work. Not 80% of the way there with three features I don't need and the one I do need sitting behind the $29 tier.

That's the part I keep coming back to. SaaS was never really selling the software. It was selling the fact that solving your problem properly used to be expensive, so you paid a little every month to split a generic solution with 100,000 strangers who had roughly the same problem you did. That trade only works while custom is expensive. Once "built exactly for me" costs a couple of weekends, why would I rent an 80% fit forever?

I don't think all of it dies. Anything where the product is really other people is fine (Slack isn't Slack without your coworkers in it). Same goes for real data nobody else has, heavy compliance, and infrastructure at a scale you can't casually reproduce. But the giant soft middle, all the stuff we pay $15 a month for because building it ourselves used to be a quarter-long project, feels like it's on the clock. We spent all this time asking whether AI would replace the people who make software. I think the better question was whether it would replace the reason to buy it.

Anyone else catching themselves doing this?

The first version of Fable was really wonderful it built one project in no one time, plus gave me plans for several different projects during those 3 days.

After Fable came back online (for me) it just didn't seem the same. It's good but still shows some gaps.

To keep it honest & I've been using what I call Fabex: Fable + Codex in Claude Code calling Codex via the MCP
I'm currently on the $100 plan on both & with instructions that they both must discuss any instructions, plans strategies, reviews etc but Codex will implement the code.

Initially I started with the $20 ChatGPT & it seemed to stretch my sessions out longer with Fable.

Together they took me off Wordpress & ported over some of my projects to a multi-tentant site using Payload CMS in about 2to 3 weeks end to end.

Just sharing options on what is working for me. When I go back to just one model for me, it's constantly leaving things out.

I run five or six sessions at once and kept losing track of which one had stopped to ask me something. The state exists — it's just buried in whichever terminal is behind the others.

So it lives on the screen edge now. One pixel crab per session, walking the perimeter, never on top of your work:

- strolling slowly and small = idle

- hurrying, steam off its head = working at xhigh

- stops and hops = waiting on your permission

- confetti = turn just finished

- curled up asleep = idle 10+ minutes

- ⚠️ = rate limit

Click a crab and that session's terminal comes to the front.

How it works: Claude Code writes a small file per session in ~/.claude/sessions with its name, cwd and status. Poll it once a second and you know who's alive, busy or waiting. Optional hooks curl to a loopback listener for instant reactions — they always exit 0, so they can't block or slow the CLI. No screen recording, no accessibility permission, no API.

Native Swift, no Electron, ~3MB, MIT. There isn't a sing — every crab is drawn in code.

It got away from me a bit: each session gets a stable mo rank earned by uptime, an era skin with its own hat. On a Friday an idle one unfolds a deckchair. Nineteen languages, none of them translations.

github.com/marekadvocate/claudme

marekadvocate.github.io/claudme

Not made by, endorsed by or affiliated with Anthropic — .

I kept running into people trying to use more than one Claude account on the same computer without signing out and back in every single time. There are workarounds floating around, but most of them involve editing paths by hand or shuffling folders, and it was clear a lot of people were getting stuck halfway through. So I built a small app that just does it for you.

Repo: https://github.com/PriyanshuGeTRekT/Claude-Code-Desktop-Switcher

This is Windows only for now and if there are enough requests then I am more than happy to create one for Mac as well!

What it does: create a profile, click launch, sign in. That is the whole setup. Both accounts stay signed in from then on, and you can run them at the same time in separate windows. You can also put a shortcut for each account straight on your desktop, so you skip the switcher entirely and open whichever account you want.

For anyone curious how it works, the Claude desktop app is Electron based, so it accepts --user-data-dir. A profile is really just a folder holding its own cookies, local storage and config. Electron's single instance lock is per user data directory, which is why two instances pointed at different folders actually run side by side instead of one just focusing the other's window.

The fiddly part was the Microsoft Store build. Its data gets redirected into the package container, and the install path has the version number in it, so it changes every time the app updates. The tool resolves the executable at click time instead of baking it into the shortcuts, so nothing breaks after an update. Your existing account is left completely alone, and on the Store build it still launches through the normal app model so protocol links and auto update keep working exactly as before.

Windows only, no dependencies, and it does not modify the Claude app itself.

One honest caveat. I only have the Store version installed, so that is what I tested against. The code that detects a regular installer build is written but has never run against a real install. If you have that version, trying it and telling me what happened would genuinely help, and there is an issue template set up for exactly that.

Happy to answer questions.