How to Use Ada

Ada is attached to the Lovelace ecosystem, so the most effective way to use her is to treat the conversation as a path through articles, code, datasets, explanations, and practical work. A session may begin with a question in plain language, continue with a search across The Library or The Square, and then move into a workspace when the next step is no longer only to read, but to build, inspect, or run something.

This page explains that process in the order most users experience it. It starts with the basic chat interface, then shows when the workspace becomes useful, how reasoning controls affect the response, how Python execution fits into the workflow, and how to use Ada carefully so the system remains useful for everyone.

Start in chat

Most sessions begin in the main chat view. This is where you ask the first question, read the answer, ask for clarification, and decide what should happen next. If your goal is to understand a concept, compare two methods, find a Library article, locate a code entry, or identify a relevant dataset, the standard chat view is usually enough to begin.

The home screen below is the default starting point. It gives you the conversation area, the prompt box, and the controls that let the session expand into a more advanced workflow when needed.

When you begin a conversation, it helps to state the topic, the level, and the kind of help you want. If you say that you are reading about PCA for the first time, Ada can stay at an introductory level. If you say that you need MATLAB code for baseline correction, Ada can treat the request as a search task instead of a teaching task. If you say that you want an explanation first and then a code example, Ada can keep both goals in the same thread and move from one to the other without restarting.

Use the workspace when the task becomes practical

The workspace is the mode Ada uses when the conversation needs a real working area. In plain terms, the workspace is where the task stops being only a question-and-answer exchange and becomes something you can inspect, edit, preview, or run. Ada can open the workspace because you ask for it directly, or because the request naturally turns into a build-oriented task.

This is useful when you want to create an interactive teaching component, inspect code imported from The Square, modify a small example, or run Python inside the same session. A professor preparing a classroom explanation of Gaussian smoothing could ask Ada to open the workspace and build a small interactive component. A researcher who finds a code entry through search could ask Ada to import it into the workspace to inspect the files and understand how it works. A student who wants to move from theory into practice could ask Ada to create a simple runnable example and explain the output after it runs.

The workspace is not a separate tool disconnected from the chat. It stays attached to the same conversation, so Ada still knows what you were discussing before it appeared. The chat remains visible and the practical work becomes another step in the same flow.

Once the workspace is open, the interface becomes easier to read if you think of it as a working table. One part of the screen keeps the conversation alive. Another part shows files, code, previews, or execution results. That arrangement is what allows Ada to keep explaining while also helping you do something concrete.

Adjust reasoning when the task needs more care

Ada includes task-level controls that affect how she approaches a request. The most important one for most users is the reasoning setting. In simple terms, reasoning controls how much effort Ada spends structuring and checking the answer before she replies.

For short retrieval tasks, a lighter setting is usually enough. If you want Ada to find a Library page, locate a code entry, or answer a direct factual question about material already in the ecosystem, the extra cost of deeper reasoning is often unnecessary. For more difficult tasks, such as building a teaching sequence, comparing several methods carefully, or planning a step-by-step explanation for a student with a specific background, a higher setting can help produce a more deliberate answer.

The goal is not to turn reasoning up by default, but to use it when the task genuinely benefits from a slower and more careful pass. In practice, that means keeping straightforward requests simple and reserving heavier reasoning for synthesis, comparison, and structured explanation.

Some users may also see a model selector. Some users can be granted access to more capable models depending on their contribution to the ecosystem. Although we would like all users to work with the most capable models, the ecosystem also has to balance growth and operating cost. When the selector is visible, it should therefore be understood as an access and capacity control rather than the main way to use Ada. For most users, the more important decision is whether the task needs a faster answer or a more careful one.

Search across the ecosystem in one conversation

One of Ada's main strengths is continuity across resource types. A user does not need to think in separate systems and decide in advance whether the answer should come from an article, a code page, a dataset, or a platform document. The conversation can begin with one kind of request and naturally continue into another.

Library articles

Use Ada to explain a Library article, summarize a section, compare two methods, or clarify a passage before moving on.

Example: "Summarize the key idea of this PCA section before I keep reading."

Platform documents

Ada can also use Lovelace's Square documentation, so you can ask how the platform works, what each space is for, or where a resource belongs.

Example: "Explain the difference between The Library and The Square in practical terms."

Code and datasets

Ada can search The Square for code entries and datasets, helping you move from an explanation to something you can inspect, compare, or use directly.

Example: "Find PLSR implementations in Python and relevant spectroscopy datasets."

Conversation and next steps

Ada keeps context across a conversation, so you can refine a question, ask for the next step, and continue into a build-oriented flow without restarting.

Example: "Based on what we just discussed, what should I open or build next?"

That continuity matters because real work rarely stays in one category. A student may begin with a conceptual question, continue into a Library article, and then ask for one practical example. A researcher may begin with a code-oriented question and then ask for the theoretical background behind the implementation. A teacher may start from a teaching objective and then ask for an interactive component or a dataset that supports that lesson. Ada is most useful when it is allowed to connect those steps instead of treating them as isolated searches.

Bring code and datasets into the same flow

Once the conceptual part is clear, the next question is often practical. You may want to know whether a method already has an implementation in the ecosystem, whether a dataset is suitable for testing an idea, or whether a code entry in one language is easier to adapt than another. Ada can help with that transition because the conversation does not need to be reset when the goal changes from understanding to finding.

This is especially useful in chemometrics, where users often move from a method name to preprocessing choices, then into an implementation, and then into data. A question about baseline correction may begin with a conceptual explanation, continue into a search for MATLAB or Python code, and end with a request to inspect one implementation in more detail. Ada is designed to keep those moves connected.

Import code into the workspace when you need to inspect or build

When a code result becomes important enough to inspect directly, the next step is often to bring it into the workspace. That allows the code to become part of the working session rather than something you only discuss abstractly. The file tree becomes visible, the active file can be read or edited, and the conversation remains available while you decide what to do with the imported material.

This is useful for understanding how an implementation is structured, creating a teaching example from an existing code entry, adapting a function to a slightly different purpose, or tracing how a method is actually implemented instead of only reading its description.

Inside the workspace, the most important shift is conceptual rather than technical. You are no longer only asking what something means. You are now working with an artifact. Ada can still explain what you see, but the session has moved into inspection, editing, and iteration.

Run Python when a compact example is more useful than a description

Some questions are easier to understand when they produce output. A short explanation of PCA scores or smoothing can be helpful, but a small runnable example often makes the idea clearer because the result can be seen immediately. Ada can therefore run compact Python examples inside the workspace and keep the execution results connected to the ongoing conversation.

This is useful for didactic work, for small demonstrations, and for quick exploratory examples where the goal is understanding rather than formal validation. You can ask Ada to create a minimal example, run it, explain the output, revise the code, and run it again without leaving the session.

Python execution should be understood as a compact educational workspace, not as a replacement for a full research environment. It is strong when the task is to test an idea, illustrate a concept, or build a small example that can be discussed immediately. It is not the right place to treat an automatically generated result as final scientific evidence without checking it carefully in a proper workflow.

Build interactive teaching material when explanation alone is not enough

Some chemometric ideas are easier to learn when the user can adjust a parameter and see the result instead of only reading about it. Ada can help create that kind of material inside the workspace. A request can begin as a conceptual explanation and then turn into a small component that shows the behavior of a smoothing parameter, a projection, or a comparison between methods.

Ada can also help you build small interactive teaching pieces, prototype an explanation visually, or continue into an editable workspace when a static answer is not enough.

Parameter explorers

Ask Ada for a compact component where changing one parameter makes the effect visible immediately.

"Create a simple component that shows how the smoothing window changes a moving average."

Step-by-step visual explanations

Ask for a component that walks through a method in a clearer visual sequence than a paragraph can offer.

"Build a visual explanation of how PCA turns many variables into a few components."

Workspace prototypes

Ask Ada to move from explanation into a small prototype, editable example, or teaching piece you can keep refining.

"Create a small editable prototype to compare ridge regression and LASSO."

These components work best when your request is focused. Ask for one concept, one visual goal, and one audience level at a time.

That makes Ada useful not only for answering questions, but also for producing small educational artifacts that support lectures, self-study, or internal teaching materials. If a static explanation is not enough, asking Ada to open the workspace and build an interactive component is often the right next step.

Understand token use and work responsibly

Ada is free for users, but each conversation still has a real cost for the project. That cost is measured partly through tokens, which are the units a language model reads and writes while processing a request. A short exchange uses relatively few tokens. A long prompt, a long answer, a large conversation history, multiple search steps, or a workspace session with imports and execution can use many more.

The practical implication is simple. Clarity helps more than volume. A focused question usually costs less and produces a better answer than a vague prompt padded with unnecessary context. If the conversation already contains the needed background, it is usually better to continue from there than to paste the same information again. If the task only needs a direct explanation, it is better not to force a heavier workflow. If a simple answer is enough, there is no reason to use deeper reasoning, import code, or run Python just because those features exist.

Responsible use matters because Lovelace's Square is a non-profit ecosystem. The system is intended to stay accessible, and that depends on users treating the available resources with care. Using Ada well therefore means asking clearly, using more demanding features when they are actually needed, and checking sources instead of asking the system to generate longer output than the task requires.

Use Ada as documentation support, not as a replacement for judgment

Ada is designed to help users understand, locate, connect, and test material across the ecosystem. She can make it much easier to move from a question to a resource and from a resource to a practical next step. That does not remove the need for scientific judgment. If a claim matters, read the source. If a code implementation matters, inspect it. If a generated result matters, verify it in the appropriate environment.

The best way to use Ada is therefore direct and pragmatic. Ask a clear question, let the conversation narrow the problem, move into the workspace when the task becomes practical, and keep the sources close to the answer. That is where the system is most useful.